【并发】CountDownLatch使用_countdownlatch.countdown-优快云博客

本文链接：https://blog.youkuaiyun.com/sfh2018/article/details/127384459

本文详细介绍了Java并发工具类CountDownLatch的使用，包括一个线程等待多个线程执行完毕和多个线程等待特定线程信号的场景。通过实例代码展示了CountDownLatch如何在多线程中实现流程控制，确保线程间的协调执行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、参考

【线程】并发流程控制的同步工具-CountDownLatch

二、介绍

CountDownLatch是一种并发流程控制的同步工具。
主要的作用是等待一个或多个线程完成任务之后，再继续完成其他线程的任务。

用法：

初始化

初始化时需要给定一个count值。

CountDownLatch countDownLatch = new CountDownLatch(5);

countDown()方法

该方法的作用是使count值-1，当count值减到0时会释放所有等待状态中的其他线程。

countDownLatch.countDown();

await()方法

让当前线程等待，直到count值变成0。可以设置等待时间。

countDownLatch.await();
//或
countDownLatch.await(5, TimeUnit.SECONDS);

三、个人demo

1.用法一：一个线程等待其他多个线程都执行完毕，再继续自己的工作

/**
 * CountDownLatch
 * 用法一：一个线程（这里指main主线程）等待其他多个线程都执行完毕，再继续自己的工作
 *
 * @author
 * @createTime 2022/10/18 10:19 上午
 **/
public class CountDownLatchTest1 {

    private static ReentrantLock lock = new ReentrantLock();

    private static CountDownLatch countDownLatch = new CountDownLatch(4);

    /**
     * 这里模拟的是等所有人到齐之后就开车出发
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(4);

        IntStream.range(0, 4).forEach(value -> {
            executorService.submit(() -> {
                lock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + "准备去坐车");
                    Thread.sleep(1000);
                    countDownLatch.countDown();
                    System.out.println(Thread.currentThread().getName() + " 坐上车了！");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            });
        });

        try {
            countDownLatch.await(5, TimeUnit.SECONDS);
            System.out.println(Thread.currentThread().getName() + "-人到齐了，出发！");
            executorService.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

pool-1-thread-4准备去坐车
pool-1-thread-4 坐上车了！
pool-1-thread-3准备去坐车
pool-1-thread-3 坐上车了！
pool-1-thread-2准备去坐车
pool-1-thread-2 坐上车了！
pool-1-thread-1准备去坐车
pool-1-thread-1 坐上车了！
main-人到齐了，出发！

2.用法二：多个线程等待某一个线程的信号，同时开始执行

/**
 * CountDownLatch
 * 用法二：多个线程等待某一个线程（这里指main主线程）的信号，同时开始执行
 *
 * @author
 * @createTime 2022/10/18 10:40 上午
 **/
public class CountDownLatchTest2 {

    private static ReentrantLock lock = new ReentrantLock();

    private static CountDownLatch countDownLatch = new CountDownLatch(1);

    /**
     * 这里模拟的是3s后再让排队的所有人上车
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        IntStream.range(0, 4).forEach(value -> {
            executorService.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "排队中...");
                    countDownLatch.await();
                    System.out.println(Thread.currentThread().getName() + "上车了！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        });

        try {
            System.out.println(Thread.currentThread().getName()+ "- 3s后所有人开始上车");
            Thread.sleep(3000);
            countDownLatch.countDown();//释放信号量
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

main- 3s后所有人开始上车
pool-1-thread-4排队中...
pool-1-thread-1排队中...
pool-1-thread-3排队中...
pool-1-thread-2排队中...
pool-1-thread-4上车了！
pool-1-thread-2上车了！
pool-1-thread-3上车了！
pool-1-thread-1上车了！