1.1 概述
CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
1.2 源码解析
首先，CyclicBarrier 的源码实现和 CountDownLatch 大同小异，CountDownLatch 基于 AQS 的共享模式的使用，而 CyclicBarrier 基于 Condition 来实现的。
1.2.1 结构图
从上述结构图看，CyclicBarrier内部使用了ReentrantLock和Condition两个类来保证同步
1.2.2 初始化
final CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {
@Override
public void run() {
System.out.println("线程集合集合完毕");
}
});
--------------------------------------------------------------------
public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
//对应的线程个数
this.parties = parties;
//当前未阻塞的线程个数
this.count = parties;
//执行的线程
this.barrierCommand = barrierAction;
}
private static class Generation {
boolean broken = false;
}
//独占锁
private final ReentrantLock lock = new ReentrantLock();
//因为CyclicBarrier是重复可利用的，一轮代表一代
private Generation generation = new Generation();
//当调用await后，会被阻塞。
private final Condition trip = lock.newCondition();
初始化代码调用的构造方法需要传入一个count和一个Runnable对象。
count对应着线程数量，Runnable对应着最后待同步的线程！
await()
在阅读源码前，朋友们先明白CyclicBarrier的一个机制：CyclicBarrier是可循环利用的，每个循环对应着一个年代，对应着CyclicBarrier就内置了一个Generation类，用来描述当前年代的状态。
private static class Generation {
//n+1个线程中只要有一个被中断或者出现超时，就将broken设置为true
boolean broken = false;
}
带着这个概念去阅读源码，思路就十分清晰了
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;
//有线程超时了，或者是被中断了
if (g.broken)
throw new BrokenBarrierException();
//如果线程被中断了，将所有线程唤醒，可中断
if (Thread.interrupted()) {
//唤醒所有等待的线程，重置count，并将g.broken=true
breakBarrier();
//抛出异常
throw new InterruptedException();
}
//await后调用后，count--
int index = --count;
if (index == 0) { //count==0，说明所有线程都调用await()了，可以执行barrierCommand了。
//是否执行最后线程了
boolean ranAction = false;
try {
final Runnable command = barrierCommand;
if (command != null)
//开始执行
command.run();
//执行最后线程了
ranAction = true;
//唤醒所有等待在trip中condition queue中的线程，开启新一轮线程同步
nextGeneration();
return 0;
} finally {
//如果执行ranAction失败，说明出现异常
if (!ranAction)
//上述代码出现异常，执行breakBarrier
breakBarrier();
}
}
//运行到这里的代码，都是n个线程中的n-1个线程
for (;;) {
try {
//阻塞式调用
if (!timed)
//阻塞将线程挂起到condition queue
trip.await();
//调用的是await(timeout)，设置的有超时时间
else if (nanos > 0L)
//最多阻塞nanos时间将线程挂起到condition queue
nanos = trip.awaitNanos(nanos);
} catch (InterruptedException ie) {
//在等待的过程中，如果线程被中断，如果其他线程还未调用breakBarrier，那么当前线程就调用
if (g == generation && ! g.broken) {
breakBarrier();
throw ie;
} else {
//如果其他线程已经breakBarrier，就直接自我中断就ok了
Thread.currentThread().interrupt();
}
}
//如果正常流程被打断，抛出BrokenBarrierException
if (g.broken)
throw new BrokenBarrierException();
//如果正常的更新换代的话，返回index
if (g != generation)
return index;
//如果await超时的话，也会breakBarrier，抛出TimeoutException
if (timed && nanos <= 0L) {
breakBarrier();
throw new TimeoutException();
}
}
} finally {
lock.unlock();
}
}
private void breakBarrier() {
//n+1个线程当中有线程被中断，或者await请求超时了，就将当前这个代打断，唤醒所有线程，各个线程自己单独处理这个异常
//设置broken为true
generation.broken = true;
//重置count
count = parties;
// 唤醒等待在trip的condition queue中的全部线程
trip.signalAll();
}
private void nextGeneration() {
//当前这轮线程全部执行成功，重置年代，开始下一轮同步
// 唤醒等待在trip的condition queue中的全部线程
trip.signalAll();
// count 重置为 parties
count = parties;
//generation也重新初始化
generation = new Generation();
}
1.2.3 总结
1、CyclicBarrier的底层是通过一个ReentrantLock、一个int变量count、一个Condition、一个Generation来实现的。
流程：
1、首先初始化一个ReentranLock对象、将count变量赋值给parties，初始化一个Condition、初始化一个Generation，Generation中只有一个broken布尔两对应着当前的同步状态是否被破坏，将Runnable对象保存给barrierCommand。
2、当线程调用await()的时候。会先抢夺lock锁，然后将count- -。如果count == 0，说明线程都已经执行完毕，可以开始执行barrierCommand了。并且通过SignalAll()来唤醒所有等待的线程，并且将Generation重新初始化，将count重新赋值为parties，开始下一轮的同步。
3、如果count != 0，说明还有其他线程未完成，就调用condition.await()方法，将线程挂起。
提示
Generation.broken
当有线程被中断或者线程被挂起超时的时候，将generation的broken设置为true，代表同步被破坏了，会立即唤醒所有之前挂起的线程。
新来的线程在操作count–之前，会判断broken，如果broken=true，就会直接抛出异常！
1.3 代码示例
public class CyclicBarrierDemo {
static class TaskThread extends Thread {
CyclicBarrier barrier;
public TaskThread(CyclicBarrier barrier) {
this.barrier = barrier;
}
@Override
public void run() {
try {
Thread.sleep(1000);
System.out.println(getName() + " 到达栅栏 A");
barrier.await();
System.out.println(getName() + " 冲破栅栏 A");
Thread.sleep(2000);
System.out.println(getName() + " 到达栅栏 B");
barrier.await();
System.out.println(getName() + " 冲破栅栏 B");
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
int threadNum = 5;
CyclicBarrier barrier = new CyclicBarrier(threadNum, new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 完成最后任务");
}
});
for(int i = 0; i < threadNum; i++) {
new TaskThread(barrier).start();
}
}
}
执行结果
Thread-1 到达栅栏 A
Thread-3 到达栅栏 A
Thread-0 到达栅栏 A
Thread-4 到达栅栏 A
Thread-2 到达栅栏 A
Thread-2 完成最后任务
Thread-2 冲破栅栏 A
Thread-1 冲破栅栏 A
Thread-3 冲破栅栏 A
Thread-4 冲破栅栏 A
Thread-0 冲破栅栏 A
Thread-4 到达栅栏 B
Thread-0 到达栅栏 B
Thread-3 到达栅栏 B
Thread-2 到达栅栏 B
Thread-1 到达栅栏 B
Thread-1 完成最后任务
Thread-1 冲破栅栏 B
Thread-0 冲破栅栏 B
Thread-4 冲破栅栏 B
Thread-2 冲破栅栏 B
Thread-3 冲破栅栏 B
244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
