CyclicBarrier
从CyclicBarrier类的名字来看，它是循环栅栏，是栅栏机制的一种实现，它在内部利用ReentrantLock锁以及Condition的线程协调机制来实现这一功能。简单的说下应用场景，假如有三个线程，我们需要当这三个线程都到达某一位置时，才执行下一步，这时我们就可以用CyclicBarrier类来实现这个功能，也就是说CyclicBarrier构建了一个类似于栅栏的事物，来挡住线程的下一步执行，当它要求的所有线程都到了指定的位置的时候，那么才打开栅栏，让这三个线程继续执行，只要有一个线程没到那么就不打开。
栅栏机制听起来有点像闭锁CountDownLatch类，但是却不相同，CountDownLatch类可以实现让一部分线程去等待另一部分线程执行完才去执行，而栅栏CyclicBarrier只是线程间的相互等待，只有全部到了指定位置，才能去执行下一步。栅栏的应用如下面示例代码：
public class Test {
public static void main (String args[]) throws InterruptedException {
CyclicBarrier cyclicBarrier=new CyclicBarrier(2, new Runnable() {
@Override
public void run() {
System.out.println("艾米莉亚开始执行了");
}
});
Thread thread1=new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
System.out.println("蕾姆到达指定地点啦");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
});
Thread thread2=new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
System.out.println("拉姆到达指定地点啦");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
});
thread1.start();
thread2.start();
}
}
//输出：
//拉姆到达指定地点啦
//蕾姆到达指定地点啦
//艾米莉亚开始执行了
从代码中看出，当thread1与thread2到达了指定位置时，才会执行预先定好的输出艾米莉亚开始执行了的方法。我们来深入CyclicBarrier类的源码看看，首先是它的构造方法：
public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
this.count = parties;
this.barrierCommand = barrierAction;
}
parties代表着可以让多少个线程互相等待，barrierCommand代表着当全部线程到达指定位置时执行的预定义方法。CyclicBarrier在源码开头定义了如下代码：
private static class Generation {
boolean broken = false;
}
private final ReentrantLock lock = new ReentrantLock();
private final Condition trip = lock.newCondition();
可以看到利用ReentrantLock锁来保持原子性，利用Condition来进行线程间的协调通信，Generation内部类代表着栅栏是否被打破，默认是false没有打破，当运行完成后会把这个属性设置成true，即打破栅栏。CyclicBarrier类一个很重要的属性就是可以重用，也就是说当此次栅栏完成后会自动调用nextGeneration方法进行重新设置状态就可以再次使用，当然你也可以手动调用reset方法：
//打破栅栏
private void breakBarrier() {
//将栅栏的状态设置为打破状态
generation.broken = true;
//未到达的线程重新设置成初始化大小
count = parties;
//唤醒处在等待队列中的线程
trip.signalAll();
}
//重新设置属性
private void nextGeneration() {
trip.signalAll();
count = parties;
generation = new Generation();
}
public void reset() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
breakBarrier(); // break the current generation
nextGeneration(); // start a new generation
} finally {
lock.unlock();
}
}
我们常说的让所有相互等待的线程都到了某个点时，才执行下一步，这个点其实是调用await方法的地方，而await方法调用的是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)
throw new BrokenBarrierException();
//如果线程被中断，那么打破栅栏，并抛出异常
if (Thread.interrupted()) {
breakBarrier();
throw new InterruptedException();
}
//每次调用都会讲未到达的线程减1，因为线程到了指定的点了
int index = --count;
//所有的线程都到达指定的点
if (index == 0) { // tripped
boolean ranAction = false;
try {
//执行预设的方法
final Runnable command = barrierCommand;
if (command != null)
command.run();
ranAction = true;
//重置属性，唤醒所有处于等待队列中的线程
nextGeneration();
return 0;
} finally {
if (!ranAction)
breakBarrier();
}
}
for (;;) {
//如果有线程没有达到，那么当前线程进入等待队列
try {
if (!timed)
trip.await();
else if (nanos > 0L)
nanos = trip.awaitNanos(nanos);
//......
} finally {
lock.unlock();
}
}
从源码中可以看出，只要有线程中断，那么就会打破栅栏，当有线程中调用了await方法都会将未到达的线程数减1，如果还有线程未到达，那么当前线程就会陷入等待，当最后一个线程达到时，将调用nextGeneration方法，唤醒所有的线程，所有的线程接着运行。