深入理解 Java CountDownLatch：一种高效的线程同步工具-优快云博客

在并发编程中，有时我们需要让多个线程并行执行，并在某个时刻等待这些线程的执行完成。Java 提供了一个非常实用的工具—— CountDownLatch，它是 java.util.concurrent 包中的一个同步工具，广泛应用于多线程编程中。

CountDownLatch 允许一个或多个线程等待其他线程的完成，然后再继续执行。通俗来说，CountDownLatch 就像一个“倒计时器”，当倒计时结束时，所有等待的线程就会被唤醒。

今天，我们将深入探讨 CountDownLatch 的工作原理、应用场景以及使用方式。

1. 什么是 `CountDownLatch`？

CountDownLatch 是一种同步工具，它使一个或多个线程等待直到其他线程的某些操作执行完成。它的核心思想是一个计数器，该计数器从一个初始值开始递减，直到计数器的值为 0 时，所有等待的线程才会被唤醒，继续执行。

CountDownLatch 的构造方法如下：

public CountDownLatch(int count);

count：初始值，表示需要等待的事件数目。每次调用 countDown() 方法，计数器会递减 1。

当计数器的值减为 0 时，所有在 await() 方法上等待的线程将会被唤醒。注意，一旦计数器的值减为 0，它不能被重新设置。

2. `CountDownLatch` 的常用方法

CountDownLatch 提供了两个核心方法：

countDown()：每次调用该方法，计数器的值减 1。
await()：使当前线程等待，直到计数器的值为 0 时才会被唤醒。

await() 方法有几种重载形式：

await()：使当前线程无限期地等待，直到计数器的值减为 0。
await(long timeout, TimeUnit unit)：使当前线程等待直到计数器的值减为 0，或者超过指定的时间。

3. `CountDownLatch` 的工作原理

我们来看看 CountDownLatch 如何工作。假设有多个线程同时运行，而我们希望这些线程都执行完某个任务后，主线程再继续执行。我们可以使用 CountDownLatch 来实现这个功能。

初始化时，CountDownLatch 的计数器被设为线程数目。
每个工作线程 执行完成后调用 countDown()，使计数器递减 1。
主线程 或其他等待线程调用 await() 方法，等待计数器变为 0。当计数器为 0 时，所有等待的线程会被唤醒，继续执行。

4. 使用场景

CountDownLatch 适用于以下几种常见场景：

并行任务的协调：当多个线程并行执行任务，且主线程需要等待所有线程完成后才能继续执行时，CountDownLatch 非常有用。例如，主线程等待所有工作线程执行完毕后汇总结果。
启动多个线程后等待它们完成：例如，你可能希望启动一组线程，然后等待这些线程的所有初始化工作完成之后再启动下一步操作。
实现测试等待机制：在一些测试框架中，你可以用 CountDownLatch 等待多个线程的启动或者完成，以确保某些操作按顺序执行。

5. 示例代码：简单的 `CountDownLatch` 用法

下面是一个简单的例子，展示如何使用 CountDownLatch 来实现主线程等待多个工作线程完成：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个 CountDownLatch，初始值为 3，表示需要等待 3 个线程
        CountDownLatch latch = new CountDownLatch(3);

        // 创建 3 个工作线程
        Thread worker1 = new Thread(new Worker(latch), "Worker-1");
        Thread worker2 = new Thread(new Worker(latch), "Worker-2");
        Thread worker3 = new Thread(new Worker(latch), "Worker-3");

        // 启动线程
        worker1.start();
        worker2.start();
        worker3.start();

        // 主线程等待，直到 latch 的计数器为 0
        latch.await();

        // 所有线程执行完毕后，主线程继续执行
        System.out.println("All workers have finished their tasks. Main thread proceeding...");
    }

    static class Worker implements Runnable {
        private final CountDownLatch latch;

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

        @Override
        public void run() {
            try {
                // 模拟每个工作线程执行任务
                System.out.println(Thread.currentThread().getName() + " is doing the task...");
                Thread.sleep((long) (Math.random() * 1000));
                System.out.println(Thread.currentThread().getName() + " has finished the task.");

                // 完成任务后，计数器递减
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

代码分析

我们创建了一个 CountDownLatch，并将计数器初始化为 3，表示我们有 3 个工作线程需要等待。
每个 Worker 线程执行完任务后调用 latch.countDown()，将计数器递减 1。
主线程调用 latch.await()，它会等待计数器值变为 0。
当所有工作线程完成任务并将计数器值递减到 0 时，主线程被唤醒，继续执行。

6. `CountDownLatch` 和 `CyclicBarrier` 的区别

虽然 CountDownLatch 和 CyclicBarrier 都是用来等待多个线程的工具，但它们有以下几点不同：

计数器：
- CountDownLatch 的计数器一旦达到 0，就不能重置，不能重复使用。
- CyclicBarrier 的计数器会在每次所有线程到达屏障后重置，可以重新使用。
应用场景：
- CountDownLatch 适用于一次性的事件等待（例如，等待所有工作线程执行完任务）。
- CyclicBarrier 适用于多次事件的协调（例如，多个线程每完成一次任务后都要等待其他线程）。