CountDownLatch类

一 CountDownLatch类的介绍

java.util.concurrent.CountDownLatch工具类用于线程间的同步与通信，协调多个线程间的执行顺序，用于确保一组线程任务执行完成，其他等待线程才会继续执行；
CountDownLatch是通过一个计数器来实现的，创建CountDownLatch对象的时候，构造参数指定计数器的初始值，也即是需要执行任务的线程数量；
在线程任务中调用CountDownLatch对象countDown()方法，计数器的值就会减一，当计数器的值为零时，表示指定的线程任务已经完成，那调用CountDownLatch对象await()方法的线程可以恢复执行任务；
CountDownLatch工具类的使用场景有异步加载资源，譬如在web服务中，先启动多个线程同时处理请求，然后再主线程中组装响应数据返回；

二 CountDownLatch类的方法

public CountDownLatch(int count)：初始化一个计数器值为count的CountDownLatch对象，count值是指一个倒计时数，也即需要先执行线程任务的数量；
public void await() throws InterruptedException：当前线程调用CountDownLatch对象的await()阻塞方法，会处于阻塞状态，需要等到其他线程调用CountDownLatch对象的countDown()方法，将初始化对象的count的值减为0，当前线程才会唤醒并继续执行；
public boolean await(long timeout, TimeUnit unit) throws InterruptedException：当前线程调用超时等待方法，会处于超时等待状态，需要等到初始化对象的count的值减为0，或超时时间到，当前线程才会唤醒并继续执行：
        如果倒计时数大于0，当前线程超时后，会被唤醒并重新执行线程任务，返回false；
        如果倒计时数等于0，当前线程会立即唤醒并重新执行线程任务，返回true；
public void countDown()：将初始化对象的count值减一，count值减到0时将会唤醒所有的阻塞线程，在一个线程任务里面可以多次使用该方法；
public long getCount()：获取初始化对象的count值；

三 CountDownLatch类的使用

public static void main(String[] args) {
    CountDownLatch countDownLatch = new CountDownLatch(2);
    new Thread(() -> {
        try {
            countDownLatch.await();
            dealWork();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }, "线程001").start();
    new Thread(() -> {
        try {
            boolean await = countDownLatch.await(2, TimeUnit.SECONDS);
            System.out.println(Thread.currentThread().getName()
                    + "是否正常醒来: " + await);
            dealWork();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }, "线程002").start();
    new Thread(() -> {
        try {
            boolean await = countDownLatch.await(10, TimeUnit.SECONDS);
            System.out.println(Thread.currentThread().getName()
                    + "是否正常醒来: " + await);
            dealWork();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }, "线程003").start();
    new Thread(() -> {
        try {
            dealWork();
            // 模拟任务执行耗时
            TimeUnit.SECONDS.sleep(3);
            dealWork();
            countDownLatch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }, "线程004").start();
    new Thread(() -> {
        try {
            dealWork();
            // 模拟任务执行耗时
            TimeUnit.SECONDS.sleep(5);
            dealWork();
            countDownLatch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }, "线程005").start();
    // 线程005任务执行..., 当前时间是: 2024-04-16 23:52:19
    // 线程004任务执行..., 当前时间是: 2024-04-16 23:52:19
    // 线程002是否正常醒来: false
    // 线程002任务执行..., 当前时间是: 2024-04-16 23:52:21
    // 线程004任务执行..., 当前时间是: 2024-04-16 23:52:22
    // 线程005任务执行..., 当前时间是: 2024-04-16 23:52:24
    // 线程003是否正常醒来: true
    // 线程001任务执行..., 当前时间是: 2024-04-16 23:52:24
    // 线程003任务执行..., 当前时间是: 2024-04-16 23:52:24
}
public static void dealWork() {
    DateTimeFormatter formatter = 
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    System.out.println(Thread.currentThread().getName()
            + "任务执行..., 当前时间是: "
            + LocalDateTime.now().format(formatter));
}

创建一个倒计时数为2的CountDownLatch对象，线程001调用CountDownLatch对象await()阻塞方法，线程002和线程003调用CountDownLatch对象await(timeout)超时等待方法，线程004和线程005调用CountDownLatch对象的countDown()倒计时数减一方法，输出的结果：
线程004和线程005会先执行线程任务，并将CountDownLatch对象的倒计时数减一；
线程002因为等待时间到了，所以重新被唤醒，继续执行代码；
线程003等待时间比较长，因为倒计数减到了0，会被立即唤醒，继续执行代码；
线程001因为倒计数减到了0，会被立即唤醒，继续执行代码；