Java进阶之路！CountDownLatch倒计时门闩实战详解

想要提升Java并发编程技能？本文深入解析了`CountDownLatch`倒计时门闩，这是一种强大的同步工具，用于协调多个线程的执行。文章详细介绍了`CountDownLatch`的工作原理，通过初始化计数器并利用`await()`和`countDown()`方法，实现线程间的同步等待。文中还探讨了`CountDownLatch`的典型应用场景，如等待多线程初始化、模拟并发用户请求以及合并子任务结果。此外，文章还对比了`CountDownLatch`与`join()`方法的区别，并分析了其在高并发场景下的性能表现，同时提供了替代方案，助你更好地掌握并发控制，优化程序性能。

CountDownLatch 在 Java 中主要用于控制并发，通过一个倒计时器允许一个或多个线程等待其他线程完成操作。其核心是一个初始化后不可重置的计数器，调用 await() 方法使线程等待直到计数器减至 0，而每次任务完成时调用 countDown() 方法将计数器减 1。典型应用场景包括：1. 等待多个线程完成初始化工作；2. 并发测试中模拟用户同时请求；3. 合并多个子任务执行结果。与 join() 方法相比，CountDownLatch 更加通用，可协调多个线程而非单一线程同步。await() 方法会抛出 InterruptedException，需进行异常处理。在高并发场景下，CountDownLatch 可能因频繁线程阻塞和竞争影响性能，此时可考虑使用 CyclicBarrier 或 CompletableFuture 替代。

CountDownLatch 在 Java 中主要用于控制并发，它允许一个或多个线程等待直到在其他线程中执行的一组操作完成。可以把它想象成一个倒计时器，当计数到达零时，所有等待的线程将被释放。

CountDownLatch 的核心在于一个计数器，这个计数器通过 CountDownLatch(int count) 初始化，count 表示需要等待的事件数量。每次一个线程完成它的任务，它就调用 countDown() 方法将计数器减 1。当计数器变为 0 时，所有调用 await() 方法等待的线程将被唤醒并继续执行。

CountDownLatch 的典型应用场景包括：

• 等待多个线程完成初始化工作： 例如，一个应用启动时，需要加载多个模块的数据，可以使用 CountDownLatch 来等待所有模块加载完成后再启动主线程。
• 并发测试： 可以使用 CountDownLatch 来模拟并发用户，等待所有用户准备就绪后同时发起请求。
• 结果合并： 当一个任务需要分解成多个子任务并行执行，然后将子任务的结果合并时，可以使用 CountDownLatch 来等待所有子任务完成。

解决方案：

CountDownLatch 的使用非常简单，主要涉及三个方法：

1. CountDownLatch(int count)： 构造方法，初始化计数器。
2. await()： 使当前线程进入等待状态，直到计数器变为 0。
3. countDown()： 将计数器减 1。

下面是一个简单的示例：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchExample {

    public static void main(String[] args) throws InterruptedException {
        int numberOfThreads = 3;
        CountDownLatch latch = new CountDownLatch(numberOfThreads);
        ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);

        for (int i = 0; i < numberOfThreads; i++) {
            final int taskId = i;
            executor.execute(() -> {
                try {
                    System.out.println("Thread " + taskId + " is running...");
                    Thread.sleep((long) (Math.random() * 3000)); // 模拟任务执行时间
                    System.out.println("Thread " + taskId + " finished.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown(); // 任务完成，计数器减 1
                }
            });
        }

        latch.await(); // 等待所有线程完成
        System.out.println("All threads finished. Main thread continues.");
        executor.shutdown();
    }
}

在这个例子中，我们创建了一个 CountDownLatch，计数器初始化为 3。然后，我们创建了一个线程池，并提交了 3 个任务。每个任务执行完成后，都会调用 countDown() 方法将计数器减 1。主线程调用 await() 方法等待，直到计数器变为 0，然后继续执行。

CountDownLatch 与 join() 方法的区别？

join() 方法是让一个线程等待另一个线程执行完成。它主要用于线程之间的同步，确保一个线程在另一个线程结束后才能继续执行。CountDownLatch 更加通用，它可以等待多个线程完成任务，并且不需要线程之间有直接的依赖关系。

此外，join() 方法只能用于等待单个线程，而 CountDownLatch 可以等待多个线程。如果需要等待多个线程，使用 CountDownLatch 更加方便。

CountDownLatch 的计数器可以重置吗？

不可以。CountDownLatch 的计数器只能初始化一次，并且只能递减，不能重置。一旦计数器变为 0，就不能再次使用。如果需要重置计数器，需要创建新的 CountDownLatch 实例。

这与 CyclicBarrier 不同，CyclicBarrier 可以在所有线程到达屏障后重置计数器，可以重复使用。

CountDownLatch 的 await() 方法会抛出 InterruptedException 吗？

是的。await() 方法会抛出 InterruptedException，这表示在等待过程中，线程被中断了。因此，在使用 await() 方法时，需要捕获 InterruptedException 异常，并进行适当的处理。

通常的处理方式是重新设置中断状态，或者直接抛出异常。例如：

try {
    latch.await();
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // 重新设置中断状态
    // 或者
    // throw new RuntimeException(e);
}

CountDownLatch 的性能如何？在高并发场景下是否适用？

CountDownLatch 的性能在高并发场景下可能会受到影响。await() 方法的实现依赖于 LockSupport.park() 方法，该方法会使线程进入阻塞状态。当大量线程同时调用 await() 方法时，可能会导致线程频繁切换，从而影响性能。

此外，countDown() 方法的实现也涉及到同步操作，在高并发场景下可能会出现竞争，从而影响性能。

因此，在高并发场景下，需要谨慎使用 CountDownLatch，并进行适当的性能测试和优化。可以考虑使用其他并发工具，例如 CyclicBarrier 或 CompletableFuture，来替代 CountDownLatch。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~