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()进入到dowait方法中，dowait方法首先要尝试获取锁lock,由于第一个线程在休眠后释放了锁lock,所以这个线程也能立即获取到锁。获取到锁后，将当前需要阻塞等待的线程数count自减1，此时count自减后为1,同样不为0，所以它也会进入for循环，它一进入for自旋也立即执行trip.await()，当前(第二个)线程线程就休眠并释放锁lock .
③当第三个线程执行到代码片段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并发编程的艺术》方腾飞