CountDownLatch 详细介绍

CountDownLatch 是 Java 中 java.util.concurrent 包提供的一个同步工具类，用于协调多个线程之间的执行顺序。它允许一个或多个线程等待，直到其他线程完成一组操作后继续执行。CountDownLatch 是一种倒计数锁存器，通过设置一个初始计数器值，线程可以通过调用 countDown() 方法递减计数器，当计数器达到 0 时，等待的线程会被唤醒。

主要特点

一次性使用：CountDownLatch 是一次性工具，一旦计数器减到 0，它不能被重置或重用。如果需要可重置的机制，可以考虑使用 CyclicBarrier。
线程等待：一个或多个线程可以通过 await() 方法等待计数器归零。
计数器递减：通过 countDown() 方法，线程可以减少计数器的值。
线程安全：CountDownLatch 是线程安全的，适合多线程并发场景。
灵活性：可以用于等待一组任务完成后再执行后续逻辑，或者让主线程等待多个子线程完成。

工作原理

CountDownLatch 内部维护一个计数器，初始化时指定一个正整数值。
调用 countDown() 方法会将计数器减 1，直到计数器为 0。
调用 await() 方法的线程会阻塞，直到计数器为 0，所有等待的线程会被唤醒。
使用基于 AQS（AbstractQueuedSynchronizer）的同步机制，确保线程安全和高效的等待/通知机制。

常见方法

CountDownLatch(int count)：构造方法，初始化计数器为指定的值 count。
void countDown()：将计数器减 1，如果计数器达到 0，唤醒所有等待的线程。
void await()：使当前线程阻塞，直到计数器归零。
boolean await(long timeout, TimeUnit unit)：使当前线程阻塞，直到计数器归零或超时，返回是否成功（true 表示计数器归零，false 表示超时）。
long getCount()：返回当前计数器的值。

使用场景

等待多个线程完成：主线程等待多个子线程完成任务后再继续执行。
并行任务协调：在任务分解为多个子任务时，确保所有子任务完成后再进行汇总。
启动信号：确保多个线程同时开始执行（通过设置计数器为 1，主线程调用 countDown() 触发所有线程）。
测试并发场景：在性能测试中，模拟多个线程同时执行某个任务。

CountDownLatch 示例代码

以下是几个使用 CountDownLatch 的实际例子，展示其在不同场景下的应用。

示例 1：主线程等待多个子线程完成

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class CountDownLatchExample1 {public static void main(String[] args) throws InterruptedException {int threadCount = 3;// 创建一个计数器，初始值为3CountDownLatch latch = new CountDownLatch(threadCount);// 创建线程池ExecutorService executor = Executors.newFixedThreadPool(threadCount);// 提交三个任务for (int i = 1; i <= threadCount; i++) {final int taskId = i;executor.submit(() -> {try {System.out.println("任务 " + taskId + " 开始执行");Thread.sleep((int) (Math.random() * 1000)); // 模拟任务耗时System.out.println("任务 " + taskId + " 完成");latch.countDown(); // 计数器减1} catch (InterruptedException e) {e.printStackTrace();}});}// 主线程等待所有任务完成System.out.println("主线程等待所有任务完成...");latch.await();System.out.println("所有任务已完成，主线程继续执行");// 关闭线程池executor.shutdown();}
}

输出示例：

主线程等待所有任务完成...
任务 1 开始执行
任务 2 开始执行
任务 3 开始执行
任务 1 完成
任务 3 完成
任务 2 完成
所有任务已完成，主线程继续执行

解释：

创建一个 CountDownLatch，初始计数器为 3。
三个线程分别执行任务，并在完成后调用 countDown() 减少计数器。
主线程调用 await()，阻塞直到计数器为 0。
当所有线程完成任务后，计数器归零，主线程继续执行。

示例 2：模拟并发任务启动

这个例子展示如何使用 CountDownLatch 让多个线程同时开始执行任务。

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class CountDownLatchExample2 {public static void main(String[] args) throws InterruptedException {int threadCount = 5;// 创建一个计数器，初始值为1CountDownLatch startSignal = new CountDownLatch(1);// 创建线程池ExecutorService executor = Executors.newFixedThreadPool(threadCount);// 提交5个任务，等待启动信号for (int i = 1; i <= threadCount; i++) {final int workerId = i;executor.submit(() -> {try {System.out.println("工人 " + workerId + " 准备就绪");startSignal.await(); // 等待启动信号System.out.println("工人 " + workerId + " 开始工作");Thread.sleep((int) (Math.random() * 1000)); // 模拟工作System.out.println("工人 " + workerId + " 完成工作");} catch (InterruptedException e) {e.printStackTrace();}});}// 主线程模拟准备时间Thread.sleep(1000);System.out.println("所有工人准备就绪，主线程发出启动信号！");startSignal.countDown(); // 发出启动信号// 关闭线程池executor.shutdown();}
}

输出示例：

工人 1 准备就绪
工人 2 准备就绪
工人 3 准备就绪
工人 4 准备就绪
工人 5 准备就绪
所有工人准备就绪，主线程发出启动信号！
工人 1 开始工作
工人 2 开始工作
工人 3 开始工作
工人 4 开始工作
工人 5 开始工作
工人 3 完成工作
工人 1 完成工作
工人 5 完成工作
工人 2 完成工作
工人 4 完成工作

解释：

使用 CountDownLatch 的计数器为 1，模拟一个启动信号。
所有工人线程调用 await() 等待主线程的信号。
主线程调用 countDown() 后，所有工人线程几乎同时开始工作。

示例 3：带超时的等待

这个例子展示如何使用带超时的 await 方法。

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;public class CountDownLatchExample3 {public static void main(String[] args) throws InterruptedException {int threadCount = 2;CountDownLatch latch = new CountDownLatch(threadCount);ExecutorService executor = Executors.newFixedThreadPool(threadCount);// 提交两个任务executor.submit(() -> {try {System.out.println("任务 1 开始执行");Thread.sleep(1000); // 模拟耗时任务System.out.println("任务 1 完成");latch.countDown();} catch (InterruptedException e) {e.printStackTrace();}});executor.submit(() -> {try {System.out.println("任务 2 开始执行");Thread.sleep(3000); // 模拟更长的耗时任务System.out.println("任务 2 完成");latch.countDown();} catch (InterruptedException e) {e.printStackTrace();}});// 主线程等待，最多等待2秒System.out.println("主线程等待，最多2秒...");boolean completed = latch.await(2, TimeUnit.SECONDS);if (completed) {System.out.println("所有任务在2秒内完成");} else {System.out.println("超时，部分任务未完成");}executor.shutdown();}
}

输出示例：

主线程等待，最多2秒...
任务 1 开始执行
任务 2 开始执行
任务 1 完成
超时，部分任务未完成
任务 2 完成

解释：

主线程设置了 2 秒的超时时间，通过 await(2, TimeUnit.SECONDS)。
任务 1 在 1 秒内完成，但任务 2 需要 3 秒，因此主线程在超时后继续执行，输出“部分任务未完成”。

CountDownLatch 与其他工具的对比

与 CyclicBarrier 的区别：
- CountDownLatch 是一次性的，计数器归零后无法重用；CyclicBarrier 可以重置并重复使用。
- CountDownLatch 通常用于主线程等待子线程；CyclicBarrier 更适合多个线程相互等待。
与 Semaphore 的区别：
- Semaphore 用于控制资源访问的并发数；CountDownLatch 用于协调线程的完成顺序。
与 wait/notify：
- CountDownLatch 提供了更简单、更高级的同步机制，基于 AQS 实现，性能更优。

使用建议

适用场景：当需要等待一组任务完成后再执行后续逻辑，或需要多个线程同时开始时。
不适用场景：如果需要重复使用计数器，建议使用 CyclicBarrier；如果需要控制并发访问量，建议使用 Semaphore。
注意事项：
- 确保初始计数器值合理，过高的计数可能导致线程长时间等待。
- countDown() 调用过多不会导致计数器变成负数，但应避免逻辑错误。
- 使用带超时的 await 方法可以避免无限等待。