1、什么是CyclicBarrier？
CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一
组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会
开门，所有被屏障拦截的线程才会继续运行。
2、CyclicBarrier的使用场景？
1、我么可以使用CyclicBarrier来模拟并发。其他的场景自己脑补。
3、CyclicBarrier的构造函数：
构造器1：CyclicBarrier默认的构造方法是CyclicBarrier（int parties），其参数表示屏障拦截的线程数 量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
使用案例：
public class CyclicBarrierDemo {public static CyclicBarrier cyclicBarrier = new CyclicBarrier(5);public static void main(String[] args) throws InterruptedException, BrokenBarrierException {for (int i = 0; i < 5; i++) {new Thread(() -> {try {Thread.sleep(2000);cyclicBarrier.await(); //使用珊栏将线程阻塞在此//当珊栏达到数量后，所有的线程同时执行sayHello()方法，因此我们可以使用CyclicBarrier来并发执行一个方法。sayHello();} catch (BrokenBarrierException e) {e.printStackTrace();} catch (InterruptedException e) {e.printStackTrace();}},"T" + i).start();}Thread.sleep(5000);System.out.println("结束。。。");}public static void sayHello() throws BrokenBarrierException, InterruptedException {System.out.println(Thread.currentThread().getName() + ": hello . . .");}
}构造器2：CyclicBarrier（int parties，Runnable barrierAction），用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景。注意！！！barrierAction只会有一条线程去执行，也就是只会执行一次，一般是最后一个到达屏障的线程去执行barrierAction 任务。
使用案例1：
public class CyclicBarrierDemo2 {static CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Task());public static void main(String[] args) throws InterruptedException {new Thread(() -> {try {cyclicBarrier.await();} catch (InterruptedException e) {e.printStackTrace();} catch (BrokenBarrierException e) {e.printStackTrace();}System.out.println("执行完 Task 后，T1 继续执行");},"T1").start();Thread.sleep(1000);new Thread(() -> {try {cyclicBarrier.await();} catch (InterruptedException e) {e.printStackTrace();} catch (BrokenBarrierException e) {e.printStackTrace();}System.out.println("执行完 Task 后，T2 继续执行");},"T2").start();}static class Task implements Runnable {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + ":run task...");}}
}使用案例2：
public class CyclicBarrierDemo3 implements Runnable {/*** 创建一个数量为4的个屏障，处理完之后执行当前类的run方法*/private CyclicBarrier c = new CyclicBarrier(4, this);/*** 假设只有4个sheet，所以只启动4个线程*/private Executor executor = Executors.newFixedThreadPool(4);/*** 保存每个sheet计算出的银流结果*/private ConcurrentHashMap<String, Integer> sheetBankWaterCount = new ConcurrentHashMap<>();private void count() {for (int i = 0; i < 4; i++) {executor.execute(() -> {// 计算当前sheet的银流数据，计算代码省略sheetBankWaterCount.put(Thread.currentThread().getName(), 1);// 银流计算完成，插入一个屏障try {c.await();} catch (InterruptedException e) {e.printStackTrace();} catch (BrokenBarrierException e) {e.printStackTrace();}});}}@Overridepublic void run() {int result = 0;// 汇总每个sheet计算出的结果for (Map.Entry<String, Integer> sheet : sheetBankWaterCount.entrySet()) {result += sheet.getValue();} // 将结果输出sheetBankWaterCount.put("result", result);System.out.println(result);}public static void main(String[] args) {CyclicBarrierDemo3 bankWaterCount = new CyclicBarrierDemo3();bankWaterCount.count();}
}
4、CyclicBarrier的实现原理：
从CyclicBarrier的api来说，跟CountLDownLatch的api差不多，那么实现方式呢？我们知道CountLDownLatch的实现是使用了AQS同步队列来实现的。那么CyclicBarrier呢？我们先看看CyclicBarrier的成员比变量：
public class CyclicBarrier {//定义了一把可重入锁，因为有全局变量parties、count需要并发操作private final ReentrantLock lock = new ReentrantLock();//使用重入锁构建一个Condition（等待队列）private final Condition trip = lock.newCondition();//屏障的线程数量，不会进行-1，是使用count进行-1，为什么不使用parties 进行-1呢？是因为CyclicBarrier 允许重置。private final int parties;//达到屏障线程数量后首先执行的Runable 任务。private final Runnable barrierCommand;private Generation generation = new Generation();//线程数量，当有线程到达屏障就-1。private int count;private static class Generation {boolean broken = false;}从成员变量中我们可以看出CyclicBarrier 的实现方式是使用ReentrantLock来保证屏障线程数量的写操作，而阻塞线程则是使用Condition等待队列。
1、我们先来看看构造函数：
public CyclicBarrier(int parties, Runnable barrierAction) {if (parties <= 0) throw new IllegalArgumentException();//设置屏障的线程数量this.parties = parties;//将count变量赋值为屏障的线程数量this.count = parties;//设置屏障的到达执行任务，不传就是nullthis.barrierCommand = barrierAction;}2、接下来我们来看看await()：
public int await() throws InterruptedException, BrokenBarrierException {try {return dowait(false, 0L);} catch (TimeoutException toe) {throw new Error(toe); // cannot happen}}private int dowait(boolean timed, long nanos)throws InterruptedException, BrokenBarrierException,TimeoutException {final ReentrantLock lock = this.lock;//加锁lock.lock();try {final Generation g = generation;//默认g的broken 是falseif (g.broken)throw new BrokenBarrierException();如果线程是被中断的，那就破坏CyclicBarrier，破坏就是将g的broken设置为true，唤醒被阻塞的线程，且重新将count=parties，然后再抛出InterruptedException异常if (Thread.interrupted()) {breakBarrier();throw new InterruptedException();}//再加锁的环境下降count 进行 -1int index = --count;if (index == 0) { // tripped//如果count 进行-1后 为0 了，说明最后一个线程达到屏障了，那就看是唤醒所有阻塞的线程boolean ranAction = false;try {//获取barrierCommand 的Runable任务，使用最后一个到达屏障的线程执行。final Runnable command = barrierCommand;if (command != null)command.run();ranAction = true;//重置为下一代，请往下看重置为下一代的实现nextGeneration();//结束方法。return 0;} finally {if (!ranAction)breakBarrier();}}// loop until tripped, broken, interrupted, or timed out//如果count 进行 -1后不为0，说明屏障还没达到完全，那就阻塞当前线程。for (;;) {try {if (!timed)//使用Condition等待队列来阻塞当前线程。trip.await();else if (nanos > 0L)nanos = trip.awaitNanos(nanos);} catch (InterruptedException ie) {if (g == generation && ! g.broken) {breakBarrier();throw ie;} else {// We're about to finish waiting even if we had not// been interrupted, so this interrupt is deemed to// "belong" to subsequent execution.Thread.currentThread().interrupt();}}if (g.broken)throw new BrokenBarrierException();if (g != generation)return index;if (timed && nanos <= 0L) {breakBarrier();throw new TimeoutException();}}} finally {//最后释放锁lock.unlock();}}//开始下一代，就是唤醒所有被阻塞的线程，且将count再次赋值为parties，generation重新创建一个赋值private void nextGeneration() {// signal completion of last generation//唤醒在Condition 等待队列中的所有线程。trip.signalAll();// set up next generation//重置count=partiescount = parties;//重置generation = new Generation();generation = new Generation();}上面就是CyclicBarrier的实现，使用ReentrantLock来并发修改屏障的线程数量，使用Condition.await()方法来阻塞线程，当屏障达到后，使用Condition.signalAll()来唤醒所有被阻塞的线程。