Java多线程同步工具类CountDownLatch详解

CountDownLatch是Java多线程中的一个同步工具类，它可以让一个或多个线程等待一组事件完成后再执行。

基本使用

CountDownLatch的基本使用场景是：在多个线程执行时，有一个或多个线程需要等待其他线程都完成任务后再继续执行。这时候可以使用CountDownLatch来实现。

在使用CountDownLatch时，首先需要创建CountDownLatch对象，设置计数器为需要等待的线程数量。当每个线程执行完任务后都会调用CountDownLatch对象的countDown()方法，将计数器减1。当计数器为0时，等待中的线程就会被唤醒，继续执行。

示例代码如下：

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int threadNum = 3;
        CountDownLatch latch = new CountDownLatch(threadNum);

        for (int i = 0; i < threadNum; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + " 执行完毕");
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

        latch.await();
        System.out.println("所有线程执行完毕");
    }
}

在这个例子中，我们创建了一个计数器为3的CountDownLatch对象，表示等待3个线程执行完毕后再继续执行。

我们在for循环中创建了3个线程，每个线程执行完任务后都会调用latch.countDown()方法。最后我们调用latch.await()方法，等待所有线程执行完毕。当所有计数器都被减为0时，等待中的线程就会被唤醒，继续执行。最后输出“所有线程执行完毕”。

高级使用

除了基本使用场景外，CountDownLatch还可以用来解决更为复杂的问题。例如，我们需要等待多个线程完成不同的任务后再执行。这时候可以使用CountDownLatch的多次countDown()方法来实现。

示例代码如下：

public class CountDownLatchExample2 {
    public static void main(String[] args) throws InterruptedException {
        int taskNum = 3;
        CountDownLatch totalLatch = new CountDownLatch(taskNum);

        CountDownLatch task1Latch = new CountDownLatch(1);
        CountDownLatch task2Latch = new CountDownLatch(1);
        CountDownLatch task3Latch = new CountDownLatch(1);

        new Thread(() -> {
            try {
                task1();
                task1Latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            totalLatch.countDown();
        }).start();

        new Thread(() -> {
            try {
                task2();
                task2Latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            totalLatch.countDown();
        }).start();

        new Thread(() -> {
            try {
                task3();
                task3Latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            totalLatch.countDown();
        }).start();

        task1Latch.await();
        task2Latch.await();
        task3Latch.await();
        System.out.println("所有任务执行完毕");
    }

    private static void task1() throws InterruptedException {
        Thread.sleep(3000);
        System.out.println("任务1执行完毕");
    }

    private static void task2() throws InterruptedException {
        Thread.sleep(2000);
        System.out.println("任务2执行完毕");
    }

    private static void task3() throws InterruptedException {
        Thread.sleep(1000);
        System.out.println("任务3执行完毕");
    }
}

在这个例子中，我们创建了一个计数器为3的CountDownLatch对象totalLatch，表示等待3个任务执行完毕后再继续执行。

我们还创建了3个单独的CountDownLatch对象task1Latch、task2Latch和task3Latch，用来分别等待任务1、任务2和任务3执行完毕。

我们创建了3个线程来执行这3个任务。当每个线程执行完任务后都会调用totalLatch.countDown()方法，将总的计数器减1。当所有任务执行完毕后，totalLatch计数器为0，等待中的线程就会被唤醒，继续执行。

最后我们等待每个任务的计数器都减为0（任务1、任务2和任务3分别对应task1Latch、task2Latch和task3Latch），然后输出“所有任务执行完毕”。

这是CountDownLatch的高级使用，可以灵活应用在各种多线程场景中。