并发工具类-CountDownLatch

CountDownLatch 是 Java 中提供的一种非常有用的并发工具类，位于 java.util.concurrent 包中。它可以使一个或多个线程等待其他线程完成一组特定的操作后再继续执行。CountDownLatch 通过维护一个计数器来实现这一点，计数器的初始值由构造函数设定。每当一个线程完成了它的工作后，就调用 countDown() 方法将计数器减 1，当计数器减为 0 时，所有等待的线程都会被唤醒并继续执行。

1. CountDownLatch 的基本概念

1.1 核心思想

CountDownLatch 的核心思想是线程之间的协调与同步，它允许一个或多个线程等待一组事件发生后再执行某个操作。主要通过以下机制实现：

• 一个或多个线程调用 await() 方法进入等待状态，直到计数器的值变为 0。
• 其他线程通过 countDown() 方法递减计数器的值，每次递减操作代表一个任务完成。
• 当计数器的值变为 0 时，所有在 await() 方法上等待的线程会被唤醒并继续执行。

1.2 工作流程

• 初始阶段：计数器值（count）是通过构造方法设置的，表示有多少个任务需要完成。
• 任务完成：每个线程执行完一个任务后调用 countDown() 方法，使计数器减 1。
• 等待线程：调用 await() 的线程会阻塞，直到计数器的值变为 0，表示所有任务都已完成。

2. CountDownLatch 的构造方法和主要方法

2.1 构造方法

CountDownLatch 只有一个构造方法：

public CountDownLatch(int count)

• count：传入的参数表示计数器的初始值，代表有多少个任务需要完成。

2.2 主要方法

1. await()：
      - 作用：调用该方法的线程会进入等待状态，直到计数器的值变为 0，或者线程被中断。
      - 示例：
        java      latch.await();      

2. countDown()：
      - 作用：将计数器的值减 1。每次调用表示一个任务完成，当计数器的值变为 0 时，所有调用了 await() 的线程会被唤醒。
      - 示例：
        java      latch.countDown();      

3. await(long timeout, TimeUnit unit)：
      - 作用：调用该方法的线程会等待指定的时间。如果计数器在指定时间内变为 0，线程继续执行；否则，线程会超时返回。
      - 示例：
        java      latch.await(5, TimeUnit.SECONDS);      

4. getCount()：
      - 作用：返回当前计数器的值。
      - 示例：
        java      long count = latch.getCount();      

3. CountDownLatch 的使用场景

CountDownLatch 适合用于多线程协调场景，以下是一些典型的使用场景：

3.1 主线程等待多个子线程执行完毕

当主线程需要等待多个子线程执行完成后再继续执行时，可以使用 CountDownLatch 来实现。例如，在主线程中创建多个子线程去处理不同的任务，主线程调用 await() 方法等待所有子线程完成后再继续执行后续操作。

3.2 实现并行任务后合并结果

在分布式系统或高并发场景中，常常需要将一个任务拆分为多个子任务，并发执行后再合并结果。CountDownLatch 可以保证主线程等待所有并发子任务完成后，再对结果进行汇总。

3.3 模拟并发压力测试

在某些并发压力测试中，可能需要多个线程同时开始执行任务。CountDownLatch 可以用来控制多个线程同时开始某个操作，从而模拟高并发场景。

4. 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个子线程for (int i = 1; i <= 3; i++) {new Thread(new Worker(latch, "Worker-" + i)).start();}// 主线程等待，直到所有子线程执行完任务latch.await();System.out.println("All workers have finished. Main thread proceeding.");}
}class Worker implements Runnable {private CountDownLatch latch;private String name;public Worker(CountDownLatch latch, String name) {this.latch = latch;this.name = name;}@Overridepublic void run() {try {// 模拟工作过程System.out.println(name + " is working.");Thread.sleep((long) (Math.random() * 1000)); // 模拟工作时间System.out.println(name + " finished work.");} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {// 任务完成，调用 countDown() 方法，使计数器减1latch.countDown();}}
}

解释：

• 我们创建了一个 CountDownLatch 对象，计数器初始值为 3。
• 创建了 3 个子线程（模拟 3 个工作者），每个线程执行完任务后调用 countDown()，将计数器减 1。
• 主线程调用 await() 方法，等待所有子线程完成任务。
• 当计数器变为 0 时，主线程继续执行。

5. CountDownLatch 的应用场景举例

5.1 多服务启动协调

在微服务架构或分布式系统中，一个服务的启动可能依赖于其他服务。如果某个服务需要等待多个依赖服务启动完成后才能启动，可以使用 CountDownLatch 来协调启动流程。

public class ServiceStartupExample {private static final int NUM_OF_SERVICES = 3;private static CountDownLatch latch = new CountDownLatch(NUM_OF_SERVICES);public static void main(String[] args) throws InterruptedException {// 启动多个依赖服务new Thread(new Service("Service-1", 2000)).start();new Thread(new Service("Service-2", 3000)).start();new Thread(new Service("Service-3", 4000)).start();// 等待所有服务启动完毕latch.await();System.out.println("All dependent services are up. Starting main service.");}static class Service implements Runnable {private String serviceName;private int startupTime;public Service(String serviceName, int startupTime) {this.serviceName = serviceName;this.startupTime = startupTime;}@Overridepublic void run() {try {// 模拟服务启动时间System.out.println(serviceName + " is starting...");Thread.sleep(startupTime);System.out.println(serviceName + " is up.");} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {// 启动完成，计数器减1latch.countDown();}}}
}

在该示例中，主线程等待所有依赖服务启动完成后才继续启动主服务。CountDownLatch 用于协调各个依赖服务的启动过程，确保它们按预期的顺序和时间依赖性执行。

6. CountDownLatch 的线程安全与性能分析

6.1 线程安全

CountDownLatch 的内部实现是线程安全的，它通过内部的锁机制和原子操作来确保计数器的递减操作是安全的。每次调用 countDown() 时，计数器会以原子的方式递减，避免了竞态条件的出现。此外，await() 方法会保证线程阻塞直到计数器变为 0，从而确保多个线程可以同步进行操作。

6.2 性能

• 开销：CountDownLatch 的开销主要在于线程的阻塞与唤醒。对于少量线程的协调，这些开销通常是可以忽略的。然而，在高并发场景下，如果涉及大量线程调用 await() 进行阻塞等待，可能会导致一些性能开销。
• 使用场景：由于 CountDownLatch 只能使用一次，计数器不能被重置，因此适用于一次性协调多个线程的场景。如果需要多个阶段的同步或复用，可以使用

CyclicBarrier 或其他并发工具。

7. CountDownLatch 与其他并发工具类的比较

• 与 CyclicBarrier：CyclicBarrier 和 CountDownLatch 都用于协调多个线程的执行，但 CyclicBarrier 允许计数器重置，适用于循环使用的场景，而 CountDownLatch 是一次性使用的。
• 与 Semaphore：Semaphore 用于控制对资源的并发访问，限制同时访问资源的线程数。而 CountDownLatch 则侧重于等待其他线程完成任务。

8. 总结

CountDownLatch 是一个非常有用的并发工具类，能够帮助多个线程之间协调执行顺序。它的工作原理基于计数器，线程可以通过 await() 方法等待，直到其他线程通过 countDown() 完成任务。CountDownLatch 在实际编程中的应用场景非常广泛，包括并发任务的协调、多线程测试中的并发压力模拟以及服务依赖启动等。

主要优点：

• 易于理解和使用，适用于需要一次性等待多个线程完成任务的场景。
• 线程安全，内部使用锁机制保证计数器的递减和线程阻塞的安全性。

缺点：

• 计数器不可重置，因此只能使用一次，如果需要重用，应该考虑使用 CyclicBarrier 等工具类。