JUC - 详解AQS家族的成员：Semaphore - 《Java技术加油站》

CountDownLatch的使用
CountDownLatch的原理
结语

封面：详解AQS家族的成员：CountDownLatch.png

王有志，一个分享硬核Java技术的互金摸鱼侠
加入Java人的提桶跑路群：共同富裕的Java人

今天我们来聊一聊AQS家族中的另一个重要成员CountDownLatch。关于CountDownLatch的面试题并不多，除了问“是什么”和“如何实现的“外，CountDownLatch还会和CyclicBarrier进行对比：

什么是CountDownLatch？它是如何实现的？
CountDownLatch和CyclicBarrier有什么区别？

按照惯例，我们依旧是按照“是什么”，“怎么用”和“如何实现的”这3步来分析CountDownLatch，至于与CyclicBarrier的差异，下一篇我们再详细分析。
Tips：今天的“是什么”和“怎么用”合并了。

CountDownLatch的使用

不知道你有没有参加过那种感动老板，并伴以“提升”组织凝聚力为主旨的公司团建？通常行政会组织一场越野徒步活动，规定每个人都到达终点后才能吃饭，美名其曰“不抛弃不放弃的团队精神”。而老板会早早的在终点拿着花名册等待，当员工到达终点后，在花名册上划掉自己的名字，当最后一名员工到达终点后，还要敲响锣鼓，告知老板可以开始下一轮的折磨了。
图1：越野徒步.png
那么这样一场越野徒步活动就可以用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产生联系的：
图2：CountDownLatch类图.png
很熟悉的结构，与ReentrantLock和Semaphore一样，都是内部的同步器类Sync继承了AQS，但不同的是CountDownLatch中的Sync不再是抽象类。
图3：AQS家族的部分成员.png
既然是继承自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技术的金融摸鱼侠王有志，我们下次再见！