Java多线程-并发工具类（一）同步屏障CyclicBarrier

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 方法之前，将一直等待。
　　返回：到达的当前线程的索引，其中，索引 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 方法等待，并打印当前线程是第几个到达栅栏。

```Java
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-0 Thread-5 Thread-3 Thread-1 Thread-2 Thread-4。

await返回值说明：索引 getParties() - 1 指示将到达的第一个线程，零指示最后一个到达的线程。数值越大越先到。

[2017-12-29 17:00:08:145] Thread-0 start!

[2017-12-29 17:00:08:145] Thread-5 start!

[2017-12-29 17:00:08:145] Thread-3 start!

[2017-12-29 17:00:08:145] Thread-1 start!

[2017-12-29 17:00:08:145] Thread-2 start!

[2017-12-29 17:00:08:145] Thread-4 start!

[2017-12-29 17:00:08:146] All 6 threads reached barrier

[2017-12-29 17:00:08:146] Thread-4 arrive index-6 await-0

[2017-12-29 17:00:08:146] Thread-0 arrive index-1 await-5

[2017-12-29 17:00:08:146] Thread-5 arrive index-2 await-4

[2017-12-29 17:00:08:146] Thread-3 arrive index-3 await-3

[2017-12-29 17:00:08:147] Thread-1 arrive index-4 await-2

[2017-12-29 17:00:08:147] Thread-2 arrive index-5 await-1

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

参考：

http://ifeve.com/concurrency-cyclicbarrier/

http://www.itzhai.com/the-introduction-and-use-of-cyclicbarrier.html#read-more

https://zhuanlan.zhihu.com/p/28637245