java并发编程专题（八）—-（JUC）实例讲解CountDownLatch

让我来为您详细讲解“Java并发编程专题（八）——(JUC)实例讲解CountDownLatch”的完整攻略。

什么是 CountDownLatch

CountDownLatch，中文翻译为倒数计数器，是 Java 标准库 java.util.concurrent 包下的一个工具类，用于控制一个或多个线程等待多个线程操作完成之后再执行。

CountDownLatch 类位于 java.util.concurrent 包下，是一个线程同步的工具类，它可以让某一个线程等待直到计数器减为 0 后再继续执行。CountDownLatch 类只提供了一个构造器：

public CountDownLatch(int count)

参数 count 表示需要等待的线程数，这个参数只能被设置一次，而且 CountDownLatch 类没有提供任何加减操作，计数器只能在构造方法中初始化。当 count 值为 0 时，表示所有需要等待的线程都已经执行完毕，等待的线程会继续执行。

CountDownLatch 使用示例

下面我们通过两个实例来说明 CountDownLatch 的具体使用。

示例一：多线程处理任务计算总耗时

假设我们有一个任务，需要分布式处理，我们需要统计总的时间，通过使用 CountDownLatch 可以方便地实现这个需求。

import java.util.concurrent.CountDownLatch;

public class TaskProcessor {
    public static void main(String[] args) throws InterruptedException {
        int nThreads = 10;
        CountDownLatch startSignal = new CountDownLatch(1);
        CountDownLatch doneSignal = new CountDownLatch(nThreads);

        for (int i = 0; i < nThreads; i++) {
            new Thread(new Worker(startSignal, doneSignal)).start();
        }

        long start = System.currentTimeMillis();
        startSignal.countDown();
        doneSignal.await();
        long end = System.currentTimeMillis();

        System.out.println("Total time: " + (end - start) + "ms");
    }

    static class Worker implements Runnable {
        private final CountDownLatch startSignal;
        private final CountDownLatch doneSignal;

        Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
            this.startSignal = startSignal;
            this.doneSignal = doneSignal;
        }

        public void run() {
            try {
                startSignal.await();
                // 模拟耗时操作
                Thread.sleep((long)(Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Processed: " + Thread.currentThread().getName());

            doneSignal.countDown();
        }
    }
}

上面这个例子使用了两个 CountDownLatch，一个是 startSignal，一个是 doneSignal。startSignal 用于让所有线程在 startSignal 调用 countDown() 后同时执行，doneSignal 用于标记所有线程执行完毕。在主线程中，我们会调用 startSignal 的 countDown() 方法，让所有线程同时执行，并在 doneSignal.await() 处等待所有线程执行完毕，最后统计总的时间。

示例二：多个线程等待单个线程执行完成后再继续执行

假设我们有一个 Main 线程和多个 Sub 线程。我们希望 Main 线程等待所有的 Sub 线程执行完毕再继续执行。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    static CountDownLatch countDownLatch = new CountDownLatch(1);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        countDownLatch.await();
                        System.out.println(Thread.currentThread().getName() + " 执行完毕");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

        Thread.sleep(3000);
        System.out.println("Main 线程执行完毕");
        countDownLatch.countDown();
    }
}

运行结果如下：

Thread-0 执行完毕
Thread-2 执行完毕
Thread-3 执行完毕
Thread-4 执行完毕
Thread-1 执行完毕
Main 线程执行完毕

在上面这个例子中，我们创建了一个 CountDownLatch 对象，然后创建了多个线程，调用了 countDownLatch.await() 方法。在 Main 线程执行完成后，调用了 countDownLatch.countDown() 方法，此时所有的线程同时开始执行。

总的来说，CountDownLatch 是一个非常方便的多线程工具类，可以实现多个线程的同步。我们可以使用它来实现复杂的分布式计算等。