Java的CountDownLatch详解及使用案例

简介

CountDownLatch是Java提供的一种用于多线程协同的工具。

它允许一个或多个线程等待其他线程完成某些操作后再继续执行。可以用下图形象的表示CountDownLatch的工作原理：

CountDownLatch.png

CountDownLatch被初始化为3，当线程1调用它的await方法时，会等待，一直到线程2、线程3、线程4分别完成某些操作并调用CountDownLatch的countDown方法将其值变为0时，线程1才能得以继续执行。

详解

CountDownLatch的作用相当于一扇门，在它变为0（结束状态）之前，这扇门一直是关闭的，没有任何线程能通过，当它变为0时，这扇门会打开，并且允许所有的线程通过，并且在它变为0后，这扇门就永远无法再关上了，后续再有线程过来时，会一直允许通过。

CountDownLatch一般有以下几个使用场景：

被初始化为N的CountDownLatch可以用来使某个线程等待，一直到有N个线程完成某个操作，或者某个操作被完成N次。比如，在多玩家的游戏中，当所有玩家都准备就绪时，游戏才可以开始。
确保某个计算在其需要的所有资源都被初始化之后才继续执行。被初始化为1的CountDownLatch叫做二元CountDownLatch，可以用来表示“资源R已经被初始化”，而所有需要R的操作都必须先在这个CountDownLatch上等待。
可以确保某个服务在其依赖的所有其他服务都已经启动之后才启动。每个服务都有一个相关的二元CountDownLatch。当启动服务S时，会首先在其依赖的所有其他服务的二元CountDownLatch上等待，在所有依赖的服务的二元CountDownLatch变为0后会将自身的二元CountDownLatch变更为0，这样所有依赖S的服务才能继续执行。

CountDownLatch包括一个计数器，该计数器被初始化为一个正数，表示需要等待的事件数量。

它的countDown方法递减计数器，表示有事件发生了，当计数器递减到0时，将释放所有等待的线程。

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

    private static final class Sync extends AbstractQueuedSynchronizer {

这里的sync其实是一个AQS，关于AQS的细节会有专门的文章来介绍，这里略过不表。

它的await方法将阻塞线程，直到计数器变为0，或者线程被中断，或者超时。

    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

它的getCount方法将会获得计数器的当前值。

    public long getCount() {
        return sync.getCount();
    }

使用案例

模拟一个控制线程控制其它工作线程开始执行的时机，并等待所有工作线程执行完毕后，再执行某些操作，完整代码如下：

public class Driver {
    public static void main(String[] args) throws InterruptedException {
        int N = 5;
        CountDownLatch startSignal = new CountDownLatch(1);
        CountDownLatch doneSignal = new CountDownLatch(N);

        for (int i = 0; i < N; ++i)
            new Thread(new Worker(startSignal, doneSignal, i + 1)).start();

        doSomethingElse();
        // 指示所有线程开始运行
        System.out.println("控制线程：工作线程们可以开始执行了");
        startSignal.countDown();
        doSomethingElse();
        // 等待所有线程执行完毕
        doneSignal.await();
        System.out.println("控制线程：所有的工作线程都已执行完毕。");
    }

    private static void doSomethingElse() throws InterruptedException {
        Thread.sleep(1000);
    }
}

public class Worker implements Runnable {
    private final CountDownLatch startSignal;
    private final CountDownLatch doneSignal;
    private int id;
    Worker(CountDownLatch startSignal, CountDownLatch doneSignal, int id) {
        this.startSignal = startSignal;
        this.doneSignal = doneSignal;
        this.id = id;
    }

    public void run() {
        try {
            // 等待主线程的开始命令
            System.out.println("工作线程" + id + "准备完毕，可以开始执行了");
            startSignal.await();
            doWork();
            // 通知主线程本线程执行完毕
            System.out.println("工作线程" + id + "执行完毕。");
            doneSignal.countDown();
        } catch (InterruptedException ex) {}
    }

    void doWork() {

    }
}

运行结果：

CountDownLatch_run.PNG