1 前言
CyclicBarrier是一种同步工具，它允许一组线程在到达一个公共的屏障点时阻塞等待，直到最后一个线程到达屏障点，屏障才能开启，此时所有被阻塞线程才能被唤醒从而继续执行。CyclicBarrier是一个可循环利用（cyclic）的的屏障（barrier）,与CountDownLatcher相比的不同之处在于，它可以重置屏障的次数，它可以在释放等待线程之后重新使用。(基于JDK1.8)
2 用法示例
CyclicBarrier默认的构造方法是CyclicBarrier（int parties），其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
class CyclicBarrierTest { static CyclicBarrier c = new CyclicBarrier(2); public static void main(String[] args) { new Thread(() -> { try { System.out.println("子线程到达屏障点"); c.await(); } catch (Exception e) { e.printStackTrace(); } System.out.println("所有线程均到达屏障点后，子线程打印" + 1); }).start(); try { System.out.println("主线程到达屏障点"); c.await(); } catch (Exception e) { e.printStackTrace(); } System.out.println("所有线程均到达屏障点后，主线程打印" + 2); } }
因为主线程和子线程的调度是由CPU决定，所以字符串“所有线程均到达屏障点后，子线程打印1“、”所有线程均到达屏障点后，主线程打印2“的输出先后顺序不固定。但”子（主）线程到达屏障点“ 打印输出一定先于”所有线程均到达屏障点后，子（主）线程打印1（2）“，因为CyclicBarrier规定“只有所有的线程都到达屏障点时，这些被阻塞线程才能继续执行”。
如果将CyclicBarrier的构造方法参数改为“new CyclicBarrier(3)”，字符串“所有线程均到达屏障点后，子（主）线程打印1（2）”一直不会被输出，因为构造方法指定了3个线程，我们实际上只在两个线程中使用了“c.await()”，这样永远不可能有3个线程都达到屏障点的时机，这两个线程将一直被阻塞等待。
另外CyclicBarrier还有一个带有两个参数的构造方法CyclicBarrier(int parties, Runnable barrierAction)，一个表示屏障拦截的线程数，另一个是Runnable类型参数barrierAction 。此barrierAction 在最后一个线程到达屏障点之后但在唤醒所有线程之前被执行。换句话说，在线程到达屏障时，优先执行barrierAction 。此屏障操作可用在任何一线程继续执行之前更新共享状态。
class CyclicBarrierTest { static CyclicBarrier c = new CyclicBarrier(2,()->{ String tName= Thread.currentThread().getName(); String gName= Thread.currentThread().getThreadGroup().getName(); System.out.println("Thread '" + tName +"' in thread group '" +gName+"' executes barrier action."); }); public static void main(String[] args) { new Thread(() -> { try { System.out.println("子线程到达屏障点"); c.await(); } catch (Exception e) { e.printStackTrace(); } System.out.println("所有线程均到达屏障点后，子线程打印" + 1); }).start(); try { System.out.println("主线程到达屏障点"); c.await(); } catch (Exception e) { e.printStackTrace(); } System.out.println("所有线程均到达屏障点后，主线程打印" + 2); } }
可以看出barrierAction先于“xxxxxxx1(2)”输出，再次验证了“在线程到达屏障时，优先执行barrierAction”。
3 成员变量与构造方法
/** The lock for guarding barrier entry */ private final ReentrantLock lock = new ReentrantLock(); /** Condition to wait on until tripped */ private final Condition trip = lock.newCondition(); /** The number of parties */ private final int parties; /* The command to run when tripped */ private final Runnable barrierCommand; /** The current generation */ private Generation generation = new Generation(); /** * Number of parties still waiting. Counts down from parties to 0 * on each generation. It is reset to parties on each new * generation or when broken. */ private int count;
lock：排他锁，保证数据访问安全。
trip：与屏障相关的条件。
parties：屏障拦截的线程数，这个值是常量初始化后不再变化。
barrierCommand：在所有线程到达屏障点时优先执行的任务。
count：当前需要阻塞等待的线程数。
generation：线程的中断状态相关。Generation是一个静态内部类,这只有一个布尔类型的成员变量broken，broken表示线程的中断。
private static class Generation { boolean broken = false; }
构造方法CyclicBarrier(int,barrierAction)主要涉及对各实例变量的初始化，对实例变量count初始为parties，当前没有任何线程被阻塞，所以counts的初值设为屏障拦截的线程数。
public CyclicBarrier(int parties, Runnable barrierAction) { if (parties <= 0) throw new IllegalArgumentException(); this.parties = parties; this.count = parties; this.barrierCommand = barrierAction; } public CyclicBarrier(int parties) { this(parties, null); }
4 主要方法
(1) await
await方法使当前线程阻塞等待。这里的两个await方法的核心逻辑都委托给行dowait方法，带参的await方法对阻塞时间做了限制，这两个await方法都响应中断。
public int await() throws InterruptedException, BrokenBarrierException { try { return dowait(false, 0L);//不做超时限制 } catch (TimeoutException toe) { throw new Error(toe); // cannot happen } } public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException { return dowait(true, unit.toNanos(timeout)); }
dowait方法是屏障拦截功能的主要实现方法。
private int dowait(boolean timed, long nanos) throws InterruptedException, BrokenBarrierException, TimeoutException { final ReentrantLock lock = this.lock; lock.lock(); try { final Generation g = generation; if (g.broken) //generation在初始化时,broken是false，而这之前又没有代码对g.broken更改 //如果出现true，表示其他方法它置为了false,这里抛出异常。 throw new BrokenBarrierException(); if (Thread.interrupted()) { //如果当前线程是中断的，就执行breakBarrier(记录中断，重置count,并唤醒所有等待线程)， breakBarrier(); throw new InterruptedException(); } int index = --count;//多一个线程阻塞，将需要阻塞等待的线程数count自减1 //若所有线程均到达屏障点，准备执行command，然后方法返回 if (index == 0) { // tripped ， boolean ranAction = false; try { final Runnable command = barrierCommand; if (command != null) command.run(); ranAction = true;//command正常完成，未发生异常 nextGeneration();//生成新的Generation. return 0; } finally { if (!ranAction)//执行command发生异常，执行breakBarrier breakBarrier(); } } //自旋等待，此时线程就被阻塞了。 //只有在 所有线程到达屏障点 或Generation broken或线程中断 或等待超时，才能退出for循环 // loop until tripped, broken, interrupted, or timed out for (;;) { try { if (!timed) trip.await();//未设置超时就不限时的休眠等待。(同时会释放锁) else if (nanos > 0L)//设置了超时，当前还未超时，就超时休眠等待。 nanos = trip.awaitNanos(nanos);//(同时会释放锁) } catch (InterruptedException ie) { if (g == generation && ! g.broken) { //generation未被其他线程修改，且未broken就执行breakBarrier 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(); } } //从trip.awaitXX中返回了（超时或被trip.signalXX方法唤醒） if (g.broken) throw new BrokenBarrierException(); if (g != generation) //generation被其他线程修改了，表示barrier被重置或所有线程都到达屏障点， //解除线程的阻塞，方法返回 return index; if (timed && nanos <= 0L) {//超时时间已过，执行breakBarrier，然后抛出异常，方法返回 breakBarrier(); throw new TimeoutException(); } } } finally { lock.unlock(); } }
dowait的整个方法体被使用锁lock保护起来，保证数据访问安全。
①dowait先检查成员变量generation的状态，如果是broken就抛出BrokenBarrierException异常。Generation是用来记录屏障拦截过程中的线程是否中断、有无其他异常发生、及屏障是否被重置等信息。
② 如果当前线程是中断的(Thread.interrupted())，就执行Generation.breakBarrier，并抛出InterruptedException。
breakBarrier的主要逻辑是记录中断 、重置count 、并唤醒所有休眠的线程
private void breakBarrier() { generation.broken = true;//中断 count = parties;//重置count为parties trip.signalAll();//将所有休眠的线程从Condition.await方法中唤醒返回 }
③将当前需要阻塞等待的线程数count自减。
④若count自减后为0了，表示所有线程均到了达屏障点，就执行command任务(command.run())，并执行nextGeneration()产生下一个Genenatrion（方便CyclicBarrier下次重新使用），然后方法返回。。nextGeneration的方法逻辑简单，唤醒所有休眠的线程、重置count、创建一个新的Generation。
private void nextGeneration() { // signal completion of last generation trip.signalAll(); // set up next generation count = parties; generation = new Generation(); }
若执行command任务过程中发生了异常,就执行breakBarrier()。
⑤若count自减后不为0了，表示还有线程未到达屏障点，此时需要进入for死循环自旋，从此时起当前线程就被阻塞了。只有当所有线程到达屏障点或Generation broken或线程中断或等待超时，才能退出for循环，方法才能得到返回。 for循环的核心逻辑：
若未设置超时就不限时地休眠等待(trip.await());若设置了超时且当前还未超时，就超时休眠等待(nanos = trip.awaitNanos(nanos))。
在休眠超时后或被trip.sinaglXXX方法唤醒后,进行一系列的条件检测，确定是否可以退出自旋。
-
如果Generation broken，就抛出异常BrokenBarrierException，方法结束。
-
若 generation被修改了(
g != generation)，表示CyclicBarrier被重置或所有线程都已到达屏障点，就方法返回，解除线程的阻塞状态。 -
若超时时间已过(
timed && nanos <= 0L)，执行breakBarrier，然后抛出异常，方法结束。
若以上三个条件均不满足，就会继续自旋。
(2) getNumberWaiting
getNumberWaiting方法返回当前正被阻塞等待的线程数。
public int getNumberWaiting() { final ReentrantLock lock = this.lock; lock.lock(); try { return parties - count;//屏障拦截的线程总数-当前还需阻塞的线程数 } finally { lock.unlock(); } }
(3) isBroken
isBroken查询当前是否broken状态
public boolean isBroken() { final ReentrantLock lock = this.lock; lock.lock(); try { return generation.broken; } finally { lock.unlock(); } }
(4) getParties
getParties方法返回越过屏障所需的线程数。parties是final常量，一经初始化后便不再变化，是一个只读的共享变量，它不存在线程安全问题，不需要用锁来保证数据访问安全。
public int getParties() { return parties; }
(5) reset
reset方法重置barrier的初始状态。如果当前还有线程在屏障点阻塞等待，则有可能抛出BrokenBarrierException异常。这里因为breakBarrier方法将generation.broken置为true，若reset方法还未执行到nextGeneration方法时，此时dowait的for自旋中又恰好检测到generation的broken为true就抛出BrokenBarrierException异常。
public void reset() { final ReentrantLock lock = this.lock; lock.lock(); try { breakBarrier(); // break the current generation nextGeneration(); // start a new generation } finally { lock.unlock(); } }
5 工作流程
假设一个项目中用代码CyclicBarrier c= new CyclicBarrier(3)构造一个CyclicBarrier对象, 阻塞等待用的是非超时版本的c.await()，那么这里c.count的初始值就是3。
①当第一个线程执行到代码片段c.await()进入到dowait方法中，dowait方法首先要尝试获取锁lock,由于它是第一个线程，此时没有线程竞争能立即获取到锁lock。获取到锁后，将当前需要阻塞等待的线程数count自减1，(count初始为3)此时count自减后为2（不为0），所以它会进入for循环，它一进入for自旋就执行trip.await()，当前(第一个)线程就休眠并释放锁lock .
②当第二个线程执行到代码片段c.await()
③当第三个线程执行到代码片段c.await()进入到dowait方法中，dowait方法首先要尝试获取锁lock, 由于第二个线程在休眠后释放了锁lock,所以此线程也能立即获取到锁。获取到锁后，将当前需要阻塞等待的线程数count自减1，此时count自减后为0，方法进入代码块if (index == 0){...}内部,若有barrierCommand，就先执行barrierCommand任务(由此可见，barrierCommand任务会在最后一个到达屏障点的线程中执行)，之后再执行方法nextGeneration(),然后从dowait方法return返回。可以看出第三个(最后一个到达屏障点的)线程执行到c.await()不会休眠等待。
④nextGeneration()方法很关键，此方法体中的trip.signalAll()将唤醒前两个(所有)线程，使得前两个线程从trip.await()的休眠中返回，继续执行for循环接下来的代码。在接下来的for循环代码中检测到if (g != generation)条件成立(nextGeneration方法将重新创建一个Generation对象，并将引用赋给成员变量generation)，从而从dowait方法中return返回，结束阻塞状态，这两个线程得以继续执行。
参考: 《Java并发编程的艺术》方腾飞