CountDownLatch详解

CountDownLatch的两种使用场景

先来看看 CountDownLatch 的源码注释。

/**
 * A synchronization aid that allows one or more threads to wait until
 * a set of operations being performed in other threads completes.
 *
 * The first is a start signal that prevents any worker from proceeding
 * until the driver is ready for them to proceed;
 * The second is a completion signal that allows the driver to wait
 * until all workers have completed.
 *
 * @since 1.5
 * @author Doug Lea
 */
public class CountDownLatch {
}

描述如下：它是一个同步工具类，允许一个或多个线程一直等待，直到其他线程运行完成后再执行。

通过描述，可以清晰的看出，CountDownLatch的两种使用场景：

• 场景1：让多个线程等待
• 场景2：和让单个线程等待。

场景1 让多个线程等待：模拟并发，让多个线程同一时刻一起执行

我们来举一个赛跑的例子。有五个选手参加赛跑，这里肯定要用到多个线程去分别模拟不同的选手，但是怎么让这个五个线程同时开始执行呢？在实际中，选手要根据发令枪来行动。在代码中我们就可以使用CountDownLatch来作为裁判的发令枪。

@Test
public void racing1() {
    // 裁判
    CountDownLatch refereeLatch = new CountDownLatch(1);
    // 有5名选手比赛赛跑
    for (int i = 0; i < 5; i++) {
        Thread t = new Thread(() -> {
            // 预备阶段等待发令员明枪
            try {
                // 选手准备完成，站在起跑线上等待起跑
                refereeLatch.await();
                // 模拟跑步
                // ...
                String thName = "【" + Thread.currentThread().getName() + "】";
                System.out.println(thName + "开始执行……");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
    }
    // 裁判明枪
    refereeLatch.countDown();
}

输出的结果如下：

【Thread-2】开始执行……
【Thread-4】开始执行……
【Thread-3】开始执行……
【Thread-0】开始执行……
【Thread-1】开始执行……

我们通过CountDownLatch.await()，让多个参与者线程启动后阻塞等待，然后在主线程调用CountDownLatch.countdown() 将计数减为0，让所有线程同一时间一起往下执行，以此实现了多个线程在同一时刻并发执行，来模拟赛跑的目的。

场景2 让单个线程等待：多个线程(任务)完成后，进行汇总合并

@Test
public void racing2() throws InterruptedException {
    // 选手有5个人所以这里要设置为5
    CountDownLatch recorderLatch = new CountDownLatch(5);
    // 有5名选手比赛赛跑
    for (int i = 0; i < 5; i++) {
        Thread t = new Thread(() -> {
            // 预备阶段等待发令员明枪
            try {
                // 选手准备完成，站在起跑线上等待起跑
                // 模拟跑步
                Thread.sleep(new Random().nextInt(5000));
                // ...
                String thName = "【" + Thread.currentThread().getName() + "】";
                System.out.println(thName + "开始执行……");
                // 选手跑到终点，记录员记录成绩
                recorderLatch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
    }
    // 等待公布成绩
    recorderLatch.await();
    System.out.println("公布成绩...");
}

输出如下：

【Thread-1】开始执行……
【Thread-4】开始执行……
【Thread-2】开始执行……
【Thread-0】开始执行……
【Thread-3】开始执行……
公布成绩...

在每个线程(任务) 完成的最后一行加上CountDownLatch.countDown()，让计数器-1。当所有线程完成-1，计数器减到0后，主线程就会继续往下执行汇总任务。

上面例子不够完整，因为我们没哟加上裁判，下面我们把裁判也加上代码如下

@Test
public void racing3() throws InterruptedException {
    // 选手有5个人所以这里要设置为5
    CountDownLatch refereeLatch = new CountDownLatch(1);
    CountDownLatch recorderLatch = new CountDownLatch(5);
    // 有5名选手比赛赛跑
    for (int i = 0; i < 5; i++) {
        Thread t = new Thread(() -> {
            // 预备阶段等待发令员明枪
            try {
                // 选手准备完成，站在起跑线上等待起跑
                refereeLatch.await();
                // 模拟跑步
                Thread.sleep(new Random().nextInt(5000));
                // ...
                String thName = "【" + Thread.currentThread().getName() + "】";
                System.out.println(thName + "开始执行……");
                // 选手跑到终点，记录员记录成绩
                recorderLatch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
    }
    System.out.println("预备...开始");
    // 裁判明枪
    refereeLatch.countDown();

    // 等待公布成绩
    recorderLatch.await();
    System.out.println("公布成绩...");
}

输出如下：

预备...开始
【Thread-1】开始执行……
【Thread-0】开始执行……
【Thread-2】开始执行……
【Thread-4】开始执行……
【Thread-3】开始执行……
公布成绩...

需要注意的地方

从上面的例子可以看出CountDownLatchApi 并不多而且还易于使用。

• CountDownLatch的构造函数中的count就是闭锁需要等待的线程数量。这个值只能被设置一次，而且不能重新设置；
• await()：调用该方法的线程会被阻塞，直到构造方法传入的 N 减到 0 的时候，才能继续往下执行；
• countDown()：使 CountDownLatch 计数值减 1；

CountDownLatch 工作原理

CountDownLatch内部原理主要是通过一个计数器来实现的，根据实际情况来设置初始值，一般设置为线程的数量。调用await()方法的线程会被阻塞，直到计数器 减到 0 的时候，才能继续往下执行。

await()方法阻塞当前线程

它们阻塞在Latch门闩/栅栏上；只有当条件满足的时候（countDown() N次，将计数减为0），它们才能同时通过这个栅栏。以此能够实现让所有的线程站在同一个起跑线上，可以想象一下赛跑的时间每个选手都要站在同一起跑线的情景。

countDown()方法则是将计数器减1

在CountDownLatch的构造函数中，指定的线程数量，只能指定一次。由于CountDownLatch采用的是减计数，因此当计数减为0时，计数器不能被重置。这是和CyclicBarrier的一个重要区别。

CountDownLatch 的源码在JUC并发工具中，也相对算是简单的；
底层基于 AbstractQueuedSynchronizer 实现，CountDownLatch 构造函数中指定的count直接赋给AQS的state。每次countDown()则都release(1)减1，最后减到0时unpark阻塞线程。这一步是由最后一个执行countdown方法的线程执行的。
而调用await()方法时，当前线程就会判断state属性是否为0，如果为0，则继续往下执行，如果不为0，则使当前线程进入等待状态，直到某个线程将state属性置为0，其就会唤醒在await()方法中等待的线程。

CountDownLatch与Thread.join

CountDownLatch的作用就是允许一个或多个线程等待其他线程完成操作，看起来有点类似join()方法，但其提供了比 join()更加灵活的API。CountDownLatch可以手动控制在n个线程里调用n次countDown()方法使计数器进行减一操作，也可以在一个线程里调用n次执行减一操作。而join()的实现原理是不停检查join线程是否存活，如果join线程存活则让当前线程永远等待。所以两者之间相对来说还是CountDownLatch使用起来较为灵活。

CountDownLatch与CyclicBarrier

CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

• CountDownLatch一般用于一个或多个线程，等待其他线程执行完任务后，再才执行
• CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行另外，CountDownLatch是减计数，计数减为0后不能重用,而CyclicBarrier是加计数，可置0后复用。

参考

[1] CountDownLatch的两种常用场景