Java并发学习-CountDownLatch实现原理全面讲解

在Java的并发编程中，有一个常见的工具类叫做CountDownLatch，用于等待一组线程完成它们的工作。本文将对CountDownLatch的原理进行全面讲解，包括它的实现原理、应用场景以及示例代码。

1. CountDownLatch的实现原理

CountDownLatch的实现原理非常简单，可以通过几个关键点来理解：

1. 每个CountDownLatch对象有一个计数器，这个计数器只能通过构造方法来初始化，之后无法修改。
2. CountDownLatch对象的计数器只能使用两个方法进行修改：countDown()和await()。
3. countDown()方法可以将计数器减1，await()方法则会阻塞直到计数器变为0。
4. 当计数器变为0时，所有处于等待状态的线程都会被唤醒。

在实际应用中，我们通常会将每个线程执行的任务数初始化为CountDownLatch对象的计数器。当每个线程完成了自己的任务后，就会调用countDown()方法，将计数器减1。最后，主线程可以调用await()方法来等待所有线程都执行完毕。

2. CountDownLatch的应用场景

CountDownLatch在Java的并发编程中非常常用，它可以应用在很多场景中，例如：

1. 等待多个线程完成任务后再执行主线程；
2. 等待多个服务启动后再启动主服务；
3. 等待某个条件满足后再进行后续操作。

3. CountDownLatch的示例代码

示例1：等待多个线程完成任务后再执行主线程

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo1 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(5);

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " 执行任务...");
                // 模拟线程执行任务，耗时1秒
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 任务完成。");
                latch.countDown();
            }).start();
        }

        System.out.println("等待5个线程执行完毕...");
        latch.await();
        System.out.println("5个线程执行完毕，主线程继续执行。");
    }
}

运行结果：

等待5个线程执行完毕...
Thread-0 执行任务...
Thread-1 执行任务...
Thread-2 执行任务...
Thread-3 执行任务...
Thread-4 执行任务...
Thread-1 任务完成。
Thread-0 任务完成。
Thread-4 任务完成。
Thread-2 任务完成。
Thread-3 任务完成。
5个线程执行完毕，主线程继续执行。

示例2：等待多个服务启动后再启动主服务

import java.util.concurrent.CountDownLatch;

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

        // 启动3个服务
        for (int i = 1; i <= 3; i++) {
            new Thread(() -> {
                System.out.println("Service-" + i + " 启动中...");
                // 模拟服务启动，耗时2秒
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Service-" + i + " 启动成功。");
                latch.countDown();
            }).start();
        }

        System.out.println("等待3个服务启动完毕...");
        latch.await();
        System.out.println("3个服务启动完毕，启动主服务。");
    }
}

运行结果：

等待3个服务启动完毕...
Service-2 启动中...
Service-1 启动中...
Service-3 启动中...
Service-1 启动成功。
Service-2 启动成功。
Service-3 启动成功。
3个服务启动完毕，启动主服务。

以上就是CountDownLatch的实现原理及应用场景，我们也给出了两个示例。在实际开发中，我们可以更加灵活地使用CountDownLatch，以满足不同的需求。