CountDownLatch与CyclicBarrier原理剖析
1.CountDownLatch
1.1 什么是CountDownLatch
CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。
CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。
1.2 CountDownLatch与join
使用join同样可以达到线程同步的效果，但是调用thread.join() 方法必须等thread 执行完毕，当前线程才能继续往下执行，而CountDownLatch通过计数器提供了更灵活的控制，只要检测到计数器为0当前线程就可以往下执行而不用管相应的thread是否执行完毕。
而且如果我们使用线程池的话，就没有办法直接调用线程的join方法了。所有另一方面来说，CountDownLatch要比join更加灵活。
1.3 CountDownLatch的基本使用
public class CountDownLatchTest {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(5);
for (int i=0; i<=5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 运行");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
latch.countDown();
}
}
}).start();
}
System.out.println("等待子线程运行结束");
latch.await();
System.out.println("子线程运行结束");
}
}
这里主线程会阻塞在latch.await()，直到CountDownLatch技术为0。
1.4 CountDownLatch原理剖析
CountDownLatch类图
从上面我们可以直到Sync继承了AQS类，CountDownLatch又持有一个成员变量Sync，所有我们可以直到CountDownLatch是基于AQS实现的。
通过构造方法我们又可以得知CountDownLatch计数器的值赋给了AQS的state变量。
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
Sync(int count) {
setState(count);
}
await()
await()的作用是使当前线程等待，直到闩锁倒计时到零（state为0），除非线程中断。
当线程调用await方法以后，当前线程会被阻塞，直到下面情况之一时才会返回：
- 当所有的线程都调用了
CountDownLatch的countDown方法后，也就是计数器为0时 - 其他线程调用了当前线程的
interrupt()方法中断了当前线程，当前线程会抛出异常然后返回
// CountDownLatch的await()实现
public void await() throws InterruptedException {
// 尝试获取共享资源
sync.acquireSharedInterruptibly(1);
}
// AQS中获取共享资源可被中断的方法
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
// 判断当前线程是否已被标记为中断，如果是则抛出异常不继续往下执行
if (Thread.interrupted())
throw new InterruptedException();
// 首先执行CountDownLatch中的内部类Sync的tryAcquireShared()方法，也就是判断当前state是否已经减为0，如果没有则执行AQS的doAcquireSharedInterruptibly方法，目的是让当前线程进入AQS阻塞队列
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
// CountDownLatch中的Sync中tryAcquireShared()方法
protected int tryAcquireShared(int acquires) {
// state不为0（意味着CountDownLatch还没有减到0）
// 不为0则返回-1，然后调用doAcquireSharedInterruptibly()方法将当前线程放入AQS队列
return (getState() == 0) ? 1 : -1;
}
由上述代码我们可以知道线程获取资源时可以被中断，并且获取的是共享资源。
名为await的方法还有一个，不过多个参数，也就是指定时间后，调用await(long timeout, TimeUnit unit)的线程会超时而返回false，如果是正常返回的，那么返回值就为true。
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
countDown()
线程调用该方法以后，计数器的值会递减，递减后如果计数器的值为0，那么就会唤醒所有因调用await方法而阻塞的线程，否则什么都不做。
// CountDownLatch中的countDown方法
public void countDown() {
sync.releaseShared(1);
}
// sync继承自AQS的releaseShared()方法
public final boolean releaseShared(int arg) {
// 调用Sync实现的tryReleaseShared方法
if (tryReleaseShared(arg)) {
// AQS中释放资源的方法，也就是激活调用await()方法被阻塞进入AQS队列的线程
doReleaseShared();
return true;
}
return false;
}
// Sync中重写的tryReleaseShared方法
// 作用是将state变量减去releases
protected boolean tryReleaseShared(int releases) {
// 循环进行CAS操作，将state做减一操作，失败则一直重试
for (;;) {
// 获得当前的state变量
int c = getState();
// 如果state已经等于0，那么直接返回false
if (c == 0)
return false;
// 将state-1
int nextc = c-1;
// CAS操作修改state，也就是将state原子性减一
// 如果nextc也就是当前修改过的state已经为0了，就会返回true，也就意味着之前调用await()方法被阻塞进入AQS队列的线程可以被激活了
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
2.CyclicBarrier
2.1 什么是CyclicBarrier
从字面理解，CyclicBarrier就是回环屏障的意思，它可以让一组线程达到一个状态后再同时执行。
- 回环的意思是在所有线程执行完毕以后，会重置CyclicBarrier的状态使它可以被重用
- 屏障的意思是线程调用await方法后都会被阻塞，这个阻塞点就被称为屏障，等到所有屏障都调用了await方法后，线程们就会冲破屏障继续向下运行
2.2 CyclicBarrier的基本使用
public class CycleBarrierTest {
private static CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable() {
// 当计数器为0时，立即执行
@Override
public void run() {
System.out.println("汇总线程：" + Thread.currentThread().getName() + " 任务合并。");
}
});
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
// 将线程A添加到线程池
executorService.submit(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程A：" + Thread.currentThread().getName() + "执行任务。");
System.out.println("线程A：到达屏障点");
cyclicBarrier.await();
System.out.println("线程A：退出屏障点");
} catch (Exception e) {
e.printStackTrace();
}
}
});
// 将线程B添加到线程池
executorService.submit(new Runnable() {
@Override
public void run() {
try {
System.out.println("线程B：" + Thread.currentThread().getName() + "执行任务。");
System.out.println("线程B：到达屏障点");
cyclicBarrier.await();
System.out.println("线程B：退出屏障点");
} catch (Exception e) {
e.printStackTrace();
}
}
});
// 调用线程池的shutdown方法关闭线程池
// 该方法会使线程池从RUNNING状态转变为SHUTDOWN状态
// SHUTDOWN状态意味着：不再接收新的任务，但是会对任务队列中的任务进行处理
executorService.shutdown();
}
}
执行结果为：
线程A：pool-1-thread-1执行任务。
线程A：到达屏障点
线程B：pool-1-thread-2执行任务。
线程B：到达屏障点
汇总线程：pool-1-thread-2 任务合并。
线程B：退出屏障点
线程A：退出屏障点
上面的例子说明了多个线程之间是相互等待的，假如计数器值为N，那么随后调用 await 方法的 N–1 个线程都会因为到达屏障点而被阻塞，当第 N 个线程调用 await 后，计 数器值为 0 了，这时候第 N 个线程才会发出通知唤醒前面的 N–1 个线程。也就是当全部 线程都到达屏障点时才能一块继续向下执行。不过这个例子并没有体现出可重用性，不过这个其实也很好理解，就是可以反复使用，感兴趣的同学可以自己去了解一下。
2.3 CyclicBarrier原理剖析
CyclicBarrier类图
由类图可知，CyclicBarrier基于独占锁实现，本质还是基于AQS实现的。
-
Generation内部有一个变量broken，用来记录当前屏障是否被打破，因为内部使用重入锁保证了线程安全，所以该属性不需要使用volatile修饰 -
parties用来记录线程个数，意味着parties个线程调用await方法以后，才会“冲破屏障” -
count一开始等于parties，每当有线程调用await方法就会减一，当count为零就意味着所有线程到达了屏障点
使用两个变量的原因就是为了达成CyclicBarrier的复用性，当count计数为0以后，会将parties重新赋值给count，从而进行复用。
public CyclicBarrier(int parties, Runnable barrierAction) {
// 判断parties的值是否合理
if (parties <= 0) throw new IllegalArgumentException();
// 记录下能够打破屏障的值
this.parties = parties;
// 记录下还需要调用几次await()方法才能打破屏障
this.count = parties;
// 屏障被打破后需要执行的任务
this.barrierCommand = barrierAction;
}
同时通过构造函数我们也可以直到，我们可以传递一个任务，而这个任务的执行时机是当所有的线程都到达屏障点以后。
await()
当线程调用await方法被阻塞，直到满足以下条件之一时就会返回：
parties个线程调用了await方法，也就是所有线程都到达了屏障点- 其他线程调用了该线程的
interrupt方法中断了该线程 - 与当前屏障点关联的
Generation对象的broken标志被设置为true时
public int await() throws InterruptedException, BrokenBarrierException {
try {
// 调用dowait方法阻塞当前线程，第一个参数为false表示第二个参数不生效
return dowait(false, 0L);
} catch (TimeoutException toe) {
throw new Error(toe); // cannot happen
}
}
public int await(long timeout, TimeUnit unit)
throws InterruptedException,
BrokenBarrierException,
TimeoutException {
// 指定timeout后会自动返回
return dowait(true, unit.toNanos(timeout));
}
dowait()
该方法实现了CyclicBarrier的核心功能。
private int dowait(boolean timed, long nanos)
throws InterruptedException, BrokenBarrierException,
TimeoutException {
// 获得锁并进行加锁，保证操作的原子性
final ReentrantLock lock = this.lock;
lock.lock();
try {
// 获得当前generation的状态，保证当前线程执行这个方法是合理的（在屏障已经被打破的情况下继续调用await方法就是不合理的）
final Generation g = generation;
// 判断屏障是否已经被打破，如果已经被打破就直接抛出异常
if (g.broken)
throw new BrokenBarrierException();
// 判断当前线程是否已经被标记为中断，如果已经标记为中断就要停止现在的操作！
if (Thread.interrupted()) {
breakBarrier();
throw new InterruptedException();
}
// count是还需要调用多少次await()才打破屏障的值
// 如果index=0就说明所有的线程都到达了屏障点（也就是屏障可以被打破），此时开始执行初始化传递的任务barrierAction
int index = --count;
if (index == 0) {
boolean ranAction = false;
try {
// barrierCommand是初始化时传入的一个线程，这个线程将会在count为0（屏障被打破）的时候执行
final Runnable command = barrierCommand;
// 执行任务
if (command != null)
command.run();
ranAction = true;
// 激活其他因调用await阻塞的线程，并且重置CyclicBarrier
nextGeneration();
return 0;
} finally {
if (!ranAction)
// 将当前屏障生成设置为已破坏并唤醒所有人
breakBarrier();
}
}
// 如果index!=0
for (;;) {
try {
// 没有设置超时时间的操作
if (!timed)
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();
if (g != generation)
return index;
if (timed && nanos <= 0L) {
breakBarrier();
throw new TimeoutException();
}
}
} finally {
// 释放锁
lock.unlock();
}
}
// 进入下一次屏障循环
// 看到这里你应该就明白了为什么CyclicBarrier可以被复用
private void nextGeneration() {
// 唤醒条件队列中的阻塞线程
trip.signalAll();
// 重置CyclicBarrier
count = parties;
generation = new Generation();
}
// 打破当前屏障
// 与nextGeneration()需要区别开的是，前者会将broken标识为true而后者是重新赋值一个Generation类（broken变为false）
private void breakBarrier() {
// 标记屏障已经被打破
generation.broken = true;
// 将count重新设置为parties
count = parties;
// 唤醒条件队列中的阻塞线程
trip.signalAll();
}
3.CountDownLatch与CyclicBarrier
CountDownLatch计数器不能重置，CyclicBarrier可以重置循环利用。CountDownLatch是基于AQS的共享模式实现的，CyclicBarrier是基于ReentrantLock和Condition实现的。- 两者最大的区别是，进行下一步动作的动作实施者是不一样的。这里的“动作实施者”有两种，一种是主线程（即执行main函数），另一种是执行任务的其他线程，后面叫这种线程为“其他线程”，区分于主线程。对于
CountDownLatch，当计数为0的时候，下一步的动作实施者是main函数；对于CyclicBarrier，下一步动作实施者是“其他线程”。