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;
// 创建一个计数器，初始值为3
CountDownLatch 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;
// 创建一个计数器，初始值为1
CountDownLatch 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方法可以避免无限等待。
总结
CountDownLatch 是一个简单而强大的同步工具，适用于协调多线程任务的完成顺序或统一启动。通过设置计数器和使用 await/countDown 方法，它能有效地控制线程间的协作。上述示例展示了其在等待任务完成、统一启动并发任务和带超时等待的场景中的应用。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
