1. 類說明
CyclicBarrier 的字面意思是可循環使用（Cyclic）的屏障（Barrier）。它要做的事情是，讓一組線程到達一個屏障（也可以叫同步點）時被阻塞，直到最後一個線程到達屏障時，屏障纔會開門，所有被屏障攔截的線程纔會繼續幹活。CyclicBarrier默認的構造方法是CyclicBarrier(int parties)，其參數表示屏障攔截的線程數量，每個線程調用await方法告訴CyclicBarrier我已經到達了屏障，然後當前線程被阻塞。
CyclicBarrier的計數器可以使用reset() 方法重置。所以CyclicBarrier能處理更爲複雜的業務場景，比如如果計算髮生錯誤，可以重置計數器，並讓線程們重新執行一次。
CyclicBarrier還提供其他有用的方法，比如getNumberWaiting方法可以獲得CyclicBarrier阻塞的線程數量。isBroken方法用來知道阻塞的線程是否被中斷。
2. 使用場景
CyclicBarrier可以用於多線程計算數據，最後合併計算結果的應用場景。比如我們用一個Excel保存了用戶所有銀行流水，每個Sheet保存一個帳戶近一年的每筆銀行流水，現在需要統計用戶的日均銀行流水，先用多線程處理每個sheet裏的銀行流水，都執行完之後，得到每個sheet的日均銀行流水，最後，再用barrierAction用這些線程的計算結果，計算出整個Excel的日均銀行流水。
3. 常用方法
構造方法摘要
CyclicBarrier(int parties)
創建一個新的 CyclicBarrier，它將在給定數量的參與者（線程）處於等待狀態時啓動，但它不會在每個 barrier 上執行預定義的操作。
CyclicBarrier(int parties, Runnable barrierAction)
創建一個新的 CyclicBarrier，它將在給定數量的參與者（線程）處於等待狀態時啓動，並在啓動 barrier 時執行給定的屏障操作，該操作由最後一個進入 barrier 的線程執行。用於在線程到達屏障時，優先執行barrierAction，方便處理更復雜的業務場景。
方法摘要
`int await() `
在所有參與者都已經在此 barrier 上調用 await 方法之前，將一直等待。
返回：到達的當前線程的索引。索引0標識最後一個到達的線程，索引 getParties() - 1 指示將到達的第一個線程
`int await(long timeout, TimeUnit unit) `
在所有參與者都已經在此屏障上調用 await 方法之前，將一直等待。
`int getNumberWaiting() `
返回當前在屏障處等待的參與者數目。
`int getParties() `
返回要求啓動此 barrier 的參與者數目。
`boolean isBroken() `
查詢此屏障是否處於損壞狀態。
`void reset() `
將屏障重置爲其初始狀態。
4. 使用示例
如下的示例，演示瞭如何使用 CyclicBarrier 實現線程同步。CyclicBarrierTest 測試類定義了線程數 threadNums 和 CyclicBarrier 實例 barrier，在構造函數中創建了 CyclicBarrier 實例，當所有線程都到達柵欄處時打印到達提示， 在 test 方法中創建線程，線程啓動後調用 await 方法等待，並打印當前線程是第幾個到達柵欄。
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class CyclicBarrierTest {
private int threadNums;
private CyclicBarrier barrier;
public CyclicBarrierTest(int threadNums) {
this.threadNums = threadNums;
barrier = new CyclicBarrier(threadNums, () -> println("All " + threadNums + " threads reached barrier.開始後續任務。"));
}
private void println(String msg) {
SimpleDateFormat sdf = new SimpleDateFormat("[YYYY-MM-dd HH:mm:ss:SSS] ");
System.out.println(sdf.format(new Date()) + msg);
}
public void test() {
for (int i = 0; i < threadNums; i++) {
new Thread(() -> {
println(Thread.currentThread().getName() + " start!");
try {
int await = barrier.await();
int parties = barrier.getParties();
int index = parties - await;
// 這組線程全部到達屏障後，再全部同時執行後續任務
println(Thread.currentThread().getName() + " arrive index-" + index + " await-" + await);
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
}
public static void main(String[] args) throws Exception {
new CyclicBarrierTest(6).test();
//new CyclicBarrierTest(6).test2();
}
} 以啓動 6 個線程爲例，執行結果如下。6 個線程幾乎同時啓動，1 毫秒後同時到達柵欄並打印出 “All 6 threads reached barrier”，6 個線程到達的次序是Thread-1 Thread-0 Thread-5 Thread-2 Thread-4 Thread-3。index-後面的數字（從小到大）指出了到達的順序，正好和await相反。
await返回值說明：索引 getParties() - 1 指示將到達的第一個線程，零指示最後一個到達的線程。數值越大越先到。
[2018-04-04 15:40:30:224] Thread-1 start!
[2018-04-04 15:40:30:224] Thread-0 start!
[2018-04-04 15:40:30:224] Thread-5 start!
[2018-04-04 15:40:30:224] Thread-2 start!
[2018-04-04 15:40:30:224] Thread-4 start!
[2018-04-04 15:40:30:224] Thread-3 start!
[2018-04-04 15:40:30:225] All 6 threads reached barrier.開始後續任務。
[2018-04-04 15:40:30:236] Thread-1 arrive index-1 await-5 parties-6
[2018-04-04 15:40:30:236] Thread-3 arrive index-6 await-0 parties-6
[2018-04-04 15:40:30:236] Thread-2 arrive index-4 await-2 parties-6
[2018-04-04 15:40:30:236] Thread-5 arrive index-3 await-3 parties-6
[2018-04-04 15:40:30:236] Thread-0 arrive index-2 await-4 parties-6
[2018-04-04 15:40:30:236] Thread-4 arrive index-5 await-1 parties-6
5. 使用示例二
如下的示例增加了 test2 方法，來測試 CyclicBarrier 的其他方法。各個線程的創建時間差了 300 ms，創建線程時打印出此時柵欄處正在等待的線程個數，await 等待的時間爲 1s 。當 CyclicBarrier 等待超時時，超時的線程打印超時提示和總的線程數，被 broken 的線程打印 broken 提示。
public void test2() throws Exception {
for (int i = 0; i < threadNums; i++) {
new Thread(() -> {
println(Thread.currentThread().getName() + " start with " + barrier.getNumberWaiting()
+ " threads waiting");
try {
barrier.await(1, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
println(Thread.currentThread().getName() + " broken " + barrier.isBroken());
} catch (TimeoutException e) {
println(Thread.currentThread().getName() + " time out to wait " + barrier.getParties() + " threds");
}
}).start();
Thread.sleep(300);
}
}從理論上分析，按照 300 ms 間隔創建線程，超時時間爲 1s ，則在第 4 個線程創建並等待時發生超時並 broken 其他線程，創建第 5 個線程時已經沒有線程等待。
以 6 個線程爲例，執行結果如下。Thread-0、Thread-1、Thread-2 依次啓動並等待，此時並沒有超時一切正常。Thread-3 啓動後，時間已經達到 1s，此時 Thread-0 等待超時打印超時提示，Thread-1、Thread-2、Thread-3 同時收到 break 消息進入 broken 狀態並打印 broken 提示。在此之後，Thread-4、Thread-5 創建並啓動，已經沒有線程在柵欄處等待，直接進入 broken 狀態並打印 broken 提示。
[2017-12-29 16:45:19:784] Thread-0 start with 0 threads waiting
[2017-12-29 16:45:20:053] Thread-1 start with 1 threads waiting
[2017-12-29 16:45:20:353] Thread-2 start with 2 threads waiting
[2017-12-29 16:45:20:653] Thread-3 start with 3 threads waiting
[2017-12-29 16:45:20:786] Thread-1 broken true
[2017-12-29 16:45:20:786] Thread-2 broken true
[2017-12-29 16:45:20:786] Thread-3 broken true
[2017-12-29 16:45:20:786] Thread-0 time out to wait 6 threds
[2017-12-29 16:45:20:953] Thread-4 start with 0 threads waiting
[2017-12-29 16:45:20:953] Thread-4 broken true
[2017-12-29 16:45:21:253] Thread-5 start with 0 threads waiting
[2017-12-29 16:45:21:253] Thread-5 broken true
總結
- CyclicBarrier 允許一系列線程相互等待對方到達一個點，正如 barrier表示的意思，該點就像一個柵欄，先到達的線程被阻塞在柵欄前，必須等到所有線程都到達了才能夠通過柵欄；
- CyclicBarrier持有一個變量 parties，表示需要全部到達的線程數量；先到達的線程調用 barrier.await方法進行等待，一旦到達的線程數達到 parties 變量所指定的數，柵欄打開，所有線程都可以通過；
- CyclicBarrier構造方法接受另一個 Runnable 類型參數 barrierAction，該參數表明再柵欄被打開的時候需要採取的動作，null表示不採取任何動作，注意該動作將會在柵欄被打開而所有線程接着運行前被執行；
- CyclicBarrier是可重用的，當最後一個線程到達的時候，柵欄被打開，所有線程通過之後柵欄重新關閉，進入下一代；
- CyclicBarrier.reset方法能夠手動重置柵欄，此時正在等待的線程會收到 BrokenBarrierException異常。
參考：
http://ifeve.com/concurrency-cyclicbarrier/
http://www.itzhai.com/the-introduction-and-use-of-cyclicbarrier.html#read-more
https://zhuanlan.zhihu.com/p/28637245
https://www.jianshu.com/p/1716ce690637