java提高篇—主線程等待分支線程執行後才執行的方法

最近打算去面試，查找一些面試題，看到京東的面試題中題，將查到的進行了總結，希望能對面試的同行有幫助。

主線程等待分支線程執行後才執行方法有以下幾種：

1. 使用countdownlatch

解釋：CountDownLatch是一個同步輔助類，通過它可以完成類似於阻塞當前線程的功能，即：一個線程或多個線程一直等待，直到其他線程執行的操作完成。
缺點：事先必須知道要多少個線程，如果不知道有多少個線程，那麼這個方法就沒有辦法。
優點：速度比較快。

2. 使用join

解釋：調用join方法，等待線程t執行完畢。
缺點：效率比較低。
優點：這個會使得線程進行排序。可以按照特定的順序進行執行。

3. 使用sleep

缺點：通過睡眠來滿足條件，只要睡眠的時間足夠大就可以達到這個效果。但是睡眠的時間不可估計。
優點：使用簡單。

4. 使用Thread.activeCount()!=1這個方法來進行判斷，現在正在存活的線程個數。

解釋：該方法返回活動線程的當前線程的線程組中的數量.
缺點：如果有本來這個系統就已經調用了多個線程，所以這個系統內就會有多個線程，判斷存活線程數量可能就不太準確。而且如果存在時間任務線程，可能沒有關閉，那麼就一直會等待。
優點：可以不用管理有多少個線程，直到所有的線程都執行完畢纔會結束。

5. 使用cyclicbarrier來進行等待

解釋：柵欄允許兩個或者多個線程在某個集合點同步。當一個線程到達集合點時，它將調用await()方法等待其它的線程。線程調用await()方法後，CyclicBarrier將阻塞這個線程並將它置入休眠狀態等待其它線程的到來。等最後一個線程調用await()方法時，CyclicBarrier將喚醒所有等待的線程然後這些線程將繼續執行。CyclicBarrier可以傳入另一個Runnable對象作爲初始化參數。當所有的線程都到達集合點後，CyclicBarrier類將Runnable對象作爲線程執行。
缺點：事先必須知道有多少個線程，如果不知道有多少個線程也沒有辦法執行。
優點：可以使所有的方法執行到某一步後都暫停，等待所有的都到達這一步之後再繼續執行。

以下石具體的代碼：

package cn.test.main;  

import java.util.concurrent.BrokenBarrierException;  
import java.util.concurrent.CountDownLatch;  
import java.util.concurrent.CyclicBarrier;  

public class MainThread { 
    static CountDownLatch countDownLatch = new CountDownLatch(10);  
    static CyclicBarrier barrier = new CyclicBarrier(11);  

    public static void main(String[] args) throws Exception {  

        long start = System.currentTimeMillis();  

        countDownLatch();  
        //join();  
        //activeCount();  
        //cyclicbarrier();  
        //sleep();  

        long end = System.currentTimeMillis();  
        System.out.println(end - start);  

    }  

    private static void sleep() {  

        for(int i =0;i<10;i++){  
            new Thread(new Runnable() {  
                @Override  
                public void run() {  
                    System.out.println(Thread.currentThread().getName());  
                }  
            }).start();  
        }  
        try {  
            Thread.sleep(10000);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  

    private static void cyclicbarrier() throws InterruptedException, BrokenBarrierException {  
        for(int i =0;i<10;i++){  
            new Thread(new Runnable() {  
                @Override  
                public void run() {  
                    System.out.println(Thread.currentThread().getName());  
                    try {  
                        barrier.await();  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    } catch (BrokenBarrierException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }).start();  
        }  
        barrier.await();  
    }  

    private static void activeCount() {  
        for(int i =0;i<10;i++){  
            new Thread(new Runnable() {  

                @Override  
                public void run() {  
                    System.out.println(Thread.currentThread().getName());  
                }  
            }).start();  
        }  
        while(Thread.activeCount()!=1){  

        }  
    }  

    private static void join() throws InterruptedException {  
        for(int i =0;i<10;i++){  

            Thread thread = new Thread(new Runnable() {  

                @Override  
                public void run() {  
                    System.out.println(Thread.currentThread().getName());  
                }  
            });  
            thread.start();  
            thread.join();  
        }  
    }  

    private static void countDownLatch() throws InterruptedException {  
        for(int i = 0;i<10;i++)  
        new Thread(new Runnable() {  

            @Override  
            public void run() {  
                System.out.println(Thread.currentThread().getName());  
                countDownLatch.countDown();  
            }  
        }).start();  
        countDownLatch.await();  
    }      
}