关注王有志，一个分享硬核Java技术的互金摸鱼侠
欢迎你加入Java人的提桶跑路群：共同富裕的Java人
今天我们来聊一聊AQS家族中的另一个重要成员CountDownLatch。关于CountDownLatch的面试题并不多，除了问“是什么”和“如何实现的“外，CountDownLatch还会和CyclicBarrier进行对比：
什么是CountDownLatch？它是如何实现的？
CountDownLatch和CyclicBarrier有什么区别？
按照惯例，我们依旧是按照“是什么”，“怎么用”和“如何实现的”这3步来分析CountDownLatch，至于与CyclicBarrier的差异，下一篇我们再详细分析。
Tips：今天的“是什么”和“怎么用”合并了。
CountDownLatch的使用
不知道你有没有参加过那种感动老板，并伴以“提升”组织凝聚力为主旨的公司团建？通常行政会组织一场越野徒步活动，规定每个人都到达终点后才能吃饭，美名其曰“不抛弃不放弃的团队精神”。而老板会早早的在终点拿着花名册等待，当员工到达终点后，在花名册上划掉自己的名字，当最后一名员工到达终点后，还要敲响锣鼓，告知老板可以开始下一轮的折磨了。
那么这样一场越野徒步活动就可以用CountDownLatch来进行简单的代码描述：
CountDownLatch countDownLatch = new CountDownLatch(10);
// 10个人进行越野徒步
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(() -> {
try {
// 每个人比前一个选手晚1秒
TimeUnit.SECONDS.sleep((finalI + 1));
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("选手[" + finalI + "]到达终点！！！");
countDownLatch.countDown();
}).start();
}
// 老板在目的地吃瓜，等待每个选手到达
countDownLatch.await();
// 开饭啦！
System.out.println("老板说：所有人都到齐了，午饭是每人一个吐司！！！");
看到这里，参加过此类团建活动的小伙伴是不是血压有些高了？但是你先别高，因为在这样一场血压飙升的团建中，我们已经不知不觉的掌握了CountDownLatch的用法了。
我们先试着从名字来理解CountDownLatch，CountDownLatch是一个组合词，CountDown译为“倒计时”，Latch译为“门闩”，结合起来就是倒计时结束后打开门闩（进行后续的动作）。再来看Doug Lea是如何解释CountDownLatch的作用的：
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
CountDownLatch是一个同步辅助工具，它允许一个或多个线程等待其他线程完成操作（进而执行后续操作）。
需要注意的是，CountDownLatch允许一个或多个线程进入等待，我们只需要在不同的线程中调用CountDownLatch.await就可以实现多个线程的等待。
CountDownLatch的原理
先来看作为AQS家族的成员，CountDownLatch是如何与AQS产生联系的：
很熟悉的结构，与ReentrantLock和Semaphore一样，都是内部的同步器类Sync继承了AQS，但不同的是CountDownLatch中的Sync不再是抽象类。
既然是继承自AQS，并且内部有计数器（倒计数也是计数）的使用，那么我们就再次搬出《AQS的今生，构建出JUC的基础》中那段关于同步状态作为计数器特性的说明：
AQS中，state不仅用作表示同步状态，也是某些同步器实现的计数器，如：
Semaphore中允许通过的线程数量，ReentrantLock中可重入特性的实现，都依赖于state作为计数器的特性。
虽然没有举CountDownLatch的例子，但我知道在经过Semaphore的分析后你一定能够猜到CountDownLatch是如何使用同步状态作为计数器特性的。接下来我们就一起来看一下同步状态在CountDownLatch中的应用。
构造方法
通过AQS家族成员的类图可以看到，CountDownLatch中的同步器Sync并没有公平与非公平的区别，因此构造器只需要提供设置计数的能力即可：
public class CountDownLatch {
public CountDownLatch(int count) {
if (count < 0){
throw new IllegalArgumentException("count < 0");
}
this.sync = new Sync(count);
}
private static final class Sync extends AbstractQueuedSynchronizer {
Sync(int count) {
setState(count);
}
}
}
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
protected final void setState(int newState) {
state = newState;
}
}
不出所料，CountDownLatch的计数依旧是回归到了AQS的state上。
countDown方法
回到徒步活动中，员工到达终点后，需要在花名册上划掉自己的名字，最后一名到达后还要敲响锣鼓。在代码实现中，我们使用了CountDownLatch.countDown表示员工到达的状态，并执行相应的动作：
public class CountDownLatch {
public void countDown() {
sync.releaseShared(1);
}
private static final class Sync extends AbstractQueuedSynchronizer {
protected boolean tryReleaseShared(int releases) {
for (;;) {
// 获取同步状态
int c = getState();
// 同步状态为0，返回失败
if (c == 0){
return false;
}
// 计数减1，并通过CAS更新
int nextc = c - 1;
if (compareAndSetState(c, nextc)) {
// 计数器为0时返回true
return nextc == 0;
}
}
}
}
}
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
}
回忆下《详解AQS家族的成员：Semaphore》中Semaphore#release方法的实现，是不是觉得似曾相识？同样是执行Sync#tryReleaseShared方法，并在成功后调用AQS的doReleaseShared方法。区别是Semaphore#tryReleaseShared的实现是计数加1，而CountDownLatch#tryReleaseShared实现是计数减1。
我们注意另一个问题，CountDownLatch的Sync#tryReleaseShared方法只有在计数器减为0时才会返回true，此时能进入AQS的doReleaseShared方法，否则都只是执行了计数器减一的操作。
此外，我们也知道AQS的doReleaseShared方法起到了唤醒AQS等待队列中节点的作用，也就是说只有在计数器减为0时，CountDownLatch才会执行一次唤醒工作。
Tips：AQS的doReleaseShared已经在《详解AQS家族的成员：Semaphore》中分析过了，就不再赘述了~~
await方法
我们知道老板一早就乘车到达了终点等待，那么老板是如何判断自己要等待呢？老板提前抵达终点后，拿出花名册统计到达人数，当发现还有人没有到达终点时，他就准备打个盹，睡一觉。
我们使用了CountDownLatch.await表示老板进入等待状态：
public class CountDownLatch {
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
}
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
if (Thread.interrupted()) {
throw new InterruptedException();
}
if (tryAcquireShared(arg) < 0) {
doAcquireSharedInterruptibly(arg);
}
}
}
是不是还是很眼熟？与Semaphore一样使用了AQS的acquireSharedInterruptibly方法，那我们重点关注CountDownLatch的Sync#tryAcquireShared方法：
public class CountDownLatch {
private static final class Sync extends AbstractQueuedSynchronizer {
protected int tryAcquireShared(int acquires) {
// 同步状态为0返回1，不为0返回-1
return (getState() == 0) ? 1 : -1;
}
}
}
该方法对同步状态做出了判断，结合AQS的acquireSharedInterruptibly方法我们可以得到以下结论：
当同步状态等于0时，
tryAcquireShared返回1，不执行doAcquireSharedInterruptibly，即执行了足够次数的countDownLatch#countDown，无需进入等待队列；当同步状态不等于0时，
tryAcquireShared返回-1，执行doAcquireSharedInterruptibly，即尚未执行足够次数的countDownLatch#countDown，需要进入等待队列。
简单来说就是在调用CountDownLatch#await方法时计数器不为0构建等待队列，为0就什么也不执行。
Tips：AQS的doAcquireSharedInterruptibly已经在《详解AQS家族的成员：Semaphore》中分析过了，就不再赘述了~~
结语
关于CountDownLatch的内容到这里就结束了，内容并不多。当我们不熟悉AQS的时候，不认识CountDownLatch的时候，会觉得CountDownLatch是一种“挺高级”的工具，但当我们深入其中时就会发现，“高级”的技术其实并不难学。
好了，如果本文对你有帮助的话，请多多点赞支持。最后欢迎大家关注分享硬核技术的金融摸鱼侠王有志，以及关注专栏《Java面试都问啥？》，我们下次再见！
