多线程编程之 CountDownLatch

CountDownLatch 是什么？

CountDownLatch 一般称为闭锁、计数器，是一种多线程同步工具，属于 AQS 体系的一员。

常用于让协调线程等待一组工作线程全部“完成工作“或“满足特定条件"后继续进行下去。

但其实也可以和 CyclicBarrier让一组线程全部到达指定点后才继续执行，不过不如 CyclicBarrier简单且不可重用，所以一般一组线程自等待的场景我们倾向于直接使用 CyclicBarrier。

CountDownLatch 怎么用？

老板有个保险箱，为了保证安全，指定 3 个亲信拿着密码。只有当 3 个亲信同时输入密码时，老板才能打开保险箱。

哪天老板说要取钱跑路了，赶紧开锁。所以亲信赶紧输入密码。

简单方式

我们可以用让老板用 int 做计数器，一直循环等待完成：

private static void rr() {
    System.out.println("老板:我要开锁");
    AtomicInteger count = new AtomicInteger(3);
    for (int i = 0; i < count.get(); i++) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                count.decrementAndGet();
            }
        }).start();
    }
    while(count.get() != 0) {
        System.out.println("老板:几个傻子给我快点");
        Thread.sleep(1000);
    }
    System.out.println("老板:拿钱跑路, 亲信卖了");
}

但是呢，会有几个问题？

• 简单的 int 会有并发问题，我们要么用 volatile 修饰，要么使用原子类

• 老板一直催催催，很烦的，需要让他安静一下，就要让他睡一会。

  可是保险箱的锁在第一次输入后，就要在限定时间内全部完成并打开，那老板睡过了怎么办。

  是不是还需要其他的线程通信手段呢？

协调线程等待工作线程

亲信 1：报告老板，咱发现一个好东西。既可以安全的输入密码，几个人不会错乱

亲信 2：全部输入之后，马上就通知您了。

亲信 3：还支持限定时间内不完成，也会通知到您出问题了。（OS：指不定我们哪个被人给“灭口”了）。

老板：好东西，搞出来给我看看。

public class CountDownLatchDemo {
    public static void main(String[] args) {
        System.out.println("老板:我要开锁");
        // 指定 3 个亲信
        CountDownLatch latch = new CountDownLatch(3);
        for (int i = 0; i < 3; i++) {
            new Thread(new Follower(latch)).start();
        }
        try {
            latch.await(1, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            System.out.println("老板:都是傻子吗,这都输入失败了");
        }
        System.out.println("老板:拿钱跑路, 亲信卖了");
    }

    private static class Follower implements Runnable {
        private CountDownLatch latch;
        public Follower(CountDownLatch latch) {
            this.latch = latch;
        }
        @Override
        public void run() {
            System.out.println("亲信:输入密码ing");
            latch.countDown();
            System.out.println("亲信:报告老板, 输入完成");
        }
    }
}
老板:我要开锁
亲信:输入密码ing
亲信:报告老板, 输入完成
亲信:输入密码ing
亲信:报告老板, 输入完成
亲信:输入密码ing
亲信:报告老板, 输入完成
老板:拿钱跑路, 亲信卖了

相互等待

苦于老板的压榨，亲信们走上了截然不同的道路。

亲信 OS：老板终究会把我们卖了，我们自己翻身做主人吧，把钱给拿了。

private static void cycleCountDown() throws InterruptedException {
    System.out.println("亲信们:不成功便成仁！！！！");
    CountDownLatch latch = new CountDownLatch(3);
    for (int i = 0; i < 3; i++) {
        new Thread(new MyFollower(latch)).start();
    }
    Thread.sleep(1000);
}

private static class MyFollower implements Runnable {
    private CountDownLatch latch;

    public MyFollower(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        System.out.println("亲信:输入密码ing");
        latch.countDown();
        System.out.println("亲信:我这边搞定了,等你们.");
        try {
            latch.await(1, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            System.out.println("OS:你们还想不想要钱了");
        }

        System.out.println("亲信:成了!!!!!");
    }
}
亲信们:不成功便成仁!!!!!
亲信:输入密码ing
亲信:输入密码ing
亲信:我这边搞定了,等你们.
亲信:我这边搞定了,等你们.
亲信:输入密码ing
亲信:我这边搞定了,等你们.
亲信:成了!!!!!
亲信:成了!!!!!
亲信:成了!!!!!

CountDownLatch 怎么实现？

主要方法如下，非常简洁：

最最关键的还是 Sync的内部类，实现了 AbstractQueuedSynchronizer(AQS)。

这里不再说明 AQS 的内容，会简单提一下，深入研究参见：AbstractQueuedSynchronizer(AQS)：并发工具的基石 (juejin.cn)

CountDownLatch 内部会持有一个 Sync的实例：private final Sync sync;

在构造时指定数量的同时，去构建这个 Sync：

public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}

Sync 接受到这个计数后，那了解 AQS 的同学马上就会明白，这是要赋予 state 这个字段真实的含义：剩余需达到指定条件的数量。

private static final class Sync extends AbstractQueuedSynchronizer {

    Sync(int count) {
        setState(count);
    }

    int getCount() {
        return getState();
    }
}

怎么让老板等着，不比比叨叨？

await 有两个重载方法：

public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}
public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

这里就是 AQS 的范畴了：

而前一个步骤是 Sync 需要实现的方法。

因为需要对 state 这个计数值进行判断，但是这个计数是在子类才赋予的含义，所以操作方法也在子类：

只有计数 state = 0 才能继续进行。

 private static final class Sync extends AbstractQueuedSynchronizer {
     protected int tryAcquireShared(int acquires) {
        return (getState() == 0) ? 1 : -1;
    }
 }

那如果没到 0，就让老板等着。AQS 内部维护了一个等待资源的队列，延伸到子类，那就是等待 getState() == 0 的情况发生。

亲信：既然老板不比比了，就要赶紧输入密码，不然超时又要吵了。

亲信 --；亲信 --；亲信–。完成！！！

输入密码，通知老板

public void countDown() {
    sync.releaseShared(1);
}

看看，看看，又是 AQS：

上面说到，如果是简单的 int，容易出现并发问题，导致输入混乱，那最后还得挨老板批。

所以需要可靠的方式：CAS + volatile（state 本质是 volatile 修饰的）

private static final class Sync extends AbstractQueuedSynchronizer {
    protected boolean tryReleaseShared(int releases) {
        // Decrement count; signal when transition to zero
        for (;;) {
            int c = getState();
            if (c == 0)
                // 已经完成不能再通知了，一次性的
                return false;
            int nextc = c - 1;
            if (compareAndSetState(c, nextc))
                // 恰好完成，返回 true，以便进行通知。
                return nextc == 0;
        }
    }
}

返回 true，就可以唤醒老板了：老板老板，输入完成！！！

总结

其实省略了很多 AQS 的内容，这东西复杂也挺复杂，搞明白也挺好明白。一言两语说不清，不如看看这两篇文章

• AbstractQueuedSynchronizer(AQS)：并发工具的基石 (juejin.cn)
• AQS Condition 源码解析 (juejin.cn)

可是还有问题，这玩意是一次性的。

平行时空 1：

老板：这玩意只能用一次有个屁用，我这是保险箱，不是射火箭！！！

CountDownLatch：射火箭我也可以的，毕竟火箭发射掌握在几个总工程师手上呢~

亲信：

平行时空 2：

亲信们：这玩意咋坏了，怎么让老板短期不发现啊

CyclicBarrier：听说有人在 cue 我？