2018.12.12更新
在學習了CyclicBarrier之後發現，CyclicBarrier也可以實現跟CountDownLatch類似的功能，只需要在它的parties中多設定一個數，將主執行緒加入等待佇列就可以了：

public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        int size = 3;
        CyclicBarrier cyclicBarrier = new CyclicBarrier
 
(size + 1);
        for (int i = 0; i < size; i++) {
            int index = i;
            pool.submit(() -> {
                try {
                    TimeUnit.SECONDS.sleep(index);
                    System.out.println("第" + index + "位運動員準備好了");
                    cyclicBarrier.await();
                }
 
 catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        try {
        //主執行緒也加入等待
            cyclicBarrier.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(size + "位運動員都準備好了，可以起跑!"
 
);
    }

執行結果：

以下是原內容：

我在使用併發執行緒柵欄的時候發現了兩種，分別是CyclicBarrier 和CountDownLatch。對於兩者的對比的文章有很多，這裡不再贅述。我來說下我的使用過程。

**需求：**有三位運動員，他們一起參加萬米賽跑，但是他們準備的時間不同，要等他們都準備好了再開始一起跑。

使用CyclicBarrier 實現：

import java.util.concurrent.*;

public class RunTest {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        int size = 3;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(size, () -> {
            System.out.println(size + "位運動員都準備好了，可以起跑！");
            pool.shutdownNow();
        });

        for (int i = 0; i < size; i++) {
            int index = i;
            pool.submit(() -> {
                try {
                    TimeUnit.SECONDS.sleep(index);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第" + index + "位運動員準備好了");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

結果：

可以看到，三位運動員準備的時間分別是1s，2s，3s。系統等到他們都準備好了，再發出起跑的訊號。在這裡CyclicBarrier 做法是在自己的構造器中new了一個runnable，等待其他執行緒都執行完，再執行此runnable中的程式碼。

我們再看看CountDownLatch怎麼實現：

import java.util.concurrent.*;

public class RunTest {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService pool = Executors.newCachedThreadPool();
        CountDownLatch countDownLatch = new CountDownLatch(3);
        int size = 3;

        for (int i = 0; i < size; i++) {
            int index = i;
            pool.submit(() -> {
                try {
                    TimeUnit.SECONDS.sleep(index);
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第" + index + "位運動員準備好了");
            });
        }
        countDownLatch.await();
        System.out.println(size + "位運動員都準備好了，可以起跑!");
    }
}

結果同上：

我們可以看到，countDownLatch是採取阻塞主執行緒的方法實現了執行緒的統一。他內部有一個計數器，我們在執行完一次執行緒任務的時候需要手動的減一個數，在主執行緒中使用 **countDownLatch.await()**監控計數器的狀態，知道計數器計到0為止，再執行主執行緒的程式碼。

在實際的開發中，我個人比較傾向於第二種方法，因為使用起來簡單，完全滿足我的需求。