一.CyclicBarrier的基本使用
在所有子线程运行过程中，设置屏障 cyclicBarrier.await(); 突破屏障后，调用CyclicBarrier中带的一个barrierCommand方法。
public class CyclicBarrierDemo {
public static class Soldier implements Runnable {
private String soldier;
private final CyclicBarrier cyclic;
public Soldier(CyclicBarrier cyclic, String soldier) {
this.soldier = soldier;
this.cyclic = cyclic;
}
@Override
public void run() {
try {
//第一个屏障（等待所有子线程一起运行到doWork()之前）
cyclic.await();
doWork();
//第二个屏障（等待所有子线程一起完成doWork()方法）
cyclic.await();
} catch (InterruptedException e) {//在等待过程中,线程被中断
e.printStackTrace();
} catch (BrokenBarrierException e) {//表示当前CyclicBarrier已经损坏.系统无法等到所有线程到齐了.
e.printStackTrace();
}
}
void doWork() {
try {
Thread.sleep(Math.abs(new Random().nextInt() % 10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(soldier + ":任务完成");
}
}
public static class BarrierRun implements Runnable {
boolean flag;
int N;
public BarrierRun(boolean flag, int N) {
this.flag = flag;
this.N = N;
}
@Override
public void run() {
if (flag) {
System.out.println("司令:[士兵" + N + "个,任务完成!]");
} else {
System.out.println("司令:[士兵" + N + "个,集合完毕!]");
flag = true;
}
}
}
public static void main(String[] args) {
final int N = 10;
Thread[] allSoldier = new Thread[N];
boolean flag = false;
// 初始化屏障器
CyclicBarrier cyclic = new CyclicBarrier(N, new BarrierRun(flag, N));
System.out.println("集合队伍! ");
for (int i = 0; i < N; i++) {
System.out.println("士兵" + i + "报道! ");
allSoldier[i] = new Thread(new Soldier(cyclic, "士兵" + i));
allSoldier[i].start();
}
}
}二.CyclicBarrier的源码分析
CyclicBarrier的应用，也是等待所有子线程工作完成才会继续屏障器后的代码。听起来和CountDownLatch的作用类似啊，但实际上它们还是有很多区别的：
- CountDownLatch要显示调用countDown()方法，且一般是用在子线程运行完成后的才执行。
- 因为CountDownLatch是一次性的，所以不能像CyclicBarrier一样在子线程运行过程中多次设置屏障。
- CountDownLatch底层用的是共享锁的机制去阻塞调用countDownLatch.await()的那个线程，直到子线程执行完成，再通过await()方法。
- CyclicBarrier底层是通过排它锁的机制去把所有子线程都放到一个条件队列中去，等到最后一个线程执行 cyclicBarrier.await()方法的时候，就会打破屏障，并唤醒前面所有被阻塞的线程。
总的来说，CountDownLatch可以做到的事，CyclicBarrier也可以做到，反之不一定，CyclicBarrier相对来说更灵活，应用场景更多。
下面来详细分析一下
2.1 初始化分析
CyclicBarrier cyclic = new CyclicBarrier(N, new BarrierRun(flag, N));
先来看一下CyclicBarrier中的类成员变量的含义
public class CyclicBarrier {
// 表示屏障的一代，即第一个屏障为一代，第二个屏障又为一代
private static class Generation {
boolean broken = false;
}
/** 进入障碍前必须获取的锁 */
private final ReentrantLock lock = new ReentrantLock();
/** 用来表示阻塞的条件 */
private final Condition trip = lock.newCondition();
/** 障碍释放前需要等待的线程数量 */
private final int parties;
/* 障碍解除后，要执行的方法*/
private final Runnable barrierCommand;
/** 当前代 */
private Generation generation = new Generation();
/**
* 表示目前还需要等待多少线程，才能结束当前轮。
*/
private int count;
/*
初始化方法，参数
parties:屏障可以阻拦多少个子线程，
barrierAction:屏障突破后要执行的任务
*/
public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
this.count = parties;
this.barrierCommand = barrierAction;
}
｝初始化主要是指定了可以阻拦的线程个数，以及突破屏障后要执行的任务。
2.2 核心方法 cyclic.await();
通过这个方法就可以看到屏障器是怎么拦截线程的，又是怎么在最后一个线程到达时，打破屏障的。
public int await() throws InterruptedException, BrokenBarrierException {
try {
// 实际调用的是这个方法，第一个是是否超时的标志false
// 第二个是时间 ，这里就是不设置时间，不会超时
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;
// 如果屏障是由于中断或者出现异常被打破了，那么直接抛出异常
if (g.broken)
throw new BrokenBarrierException();
// 如果当前线程出现了中断，
if (Thread.interrupted()) {
/*
private void breakBarrier() {
//这个方法内部会设置 g.broken = true;
generation.broken = true;
count = parties;
// 且唤醒所有阻塞的线程，但是唤醒后的每个线程继续执行，还是会根据 if(g.broken) 抛出异常
trip.signalAll();
}
*/
breakBarrier();
throw new InterruptedException();
}
// 线程正常执行到这里，屏障等待拦截的线程减1
int index = --count;
if (index == 0) { // 如果是最后一个线程到达
boolean ranAction = false;
try {
final Runnable command = barrierCommand;
if (command != null)
command.run(); //调用屏障解除后的需要运行的任务
ranAction = true;
/*
里面的逻辑主要是，唤醒条件队列中的线程，并且声称一个新一代的屏障器
*/
nextGeneration();
return 0;
} finally {
// 这里是假设command.run()出了异常，那么也调用breakBarrier()方法。
if (!ranAction)
breakBarrier();
}
}
// loop until tripped, broken, interrupted, or timed out
for (;;) {
try {
if (!timed) // 如果没有超时，那么把当前线程放到trip条件队列中去，释放锁。其他线程可以获取锁了。
trip.await();
else if (nanos > 0L)
nanos = trip.awaitNanos(nanos);
} catch (InterruptedException ie) {
if (g == generation && ! g.broken) {
breakBarrier();
throw ie;
} else {
Thread.currentThread().interrupt();
}
}
// 呼应前面，一个线程出现中断异常后，其他线程也要抛出异常
if (g.broken)
throw new BrokenBarrierException();
// 被唤醒后，正常返回。 执行完成await()方法
if (g != generation)
return index;
// 如果超时，也会调用 breakBarrier()
if (timed && nanos <= 0L) {
breakBarrier();
throw new TimeoutException();
}
}
} finally {
lock.unlock();
}
}总结：
CyclicBarrier比较符合人们对屏障拦截器的构想，是通过排他锁，把所有线程全部阻塞在条件队列中，等到最后一个线程到来的时候，就解除屏障，唤醒所有线程继续执行。
CountDownLatch就不同，它是通过共享锁一开始就设置好了里面有多少个共享锁，因此共享锁不释放的话，主线程调用latch.await()就会阻塞。直到最后一个子线程调用latch.countDown()方法，共享锁state==0被释放，并且主线程被唤醒。