CountDownLatch作用及使用场景

概念

CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程执行完后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有框架服务之后执行。

CountDownLatch的用法

CountDownLatch典型用法1：某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为n new CountDownLatch(n) ，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await() 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

CountDownLatch典型用法2：实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的CountDownLatch(1)，将其计数器初始化为1，多个线程在开始执行任务前首先 coundownlatch.await()，当主线程调用 countDown() 时，计数器变为0，多个线程同时被唤醒。

CountDownLatch原理

CountDownLatch是通过一个计数器来实现的，计数器的初始化值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就相应得减1。当计数器到达0时，表示所有的线程都已完成任务，然后在闭锁上等待的线程就可以恢复执行任务。

/**
 * CountDownLatch:多线程控制工具类，用来控制线程等待，它可以让某一个线程等待知道倒计时结束，再开始执行
 */
public class CountDownLatchDemo {
 
    //实例化并指定计数个数
    private  static CountDownLatch countDown = new CountDownLatch(3);
 
    public static Runnable r1 = new Runnable(){
        @Override
        public void run() {
            try{
                Thread.sleep(1000);
                System.out.println("r1 run");
                countDown.countDown();//个数-1
            }catch (Exception e){
                e.printStackTrace();
            }
 
        }
    };
 
   public static Runnable r2 = new Runnable() {
        @Override
        public void run() {
            try{
                Thread.sleep(2000);
                System.out.println("r2 run");
                countDown.countDown();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    };
 
    public  static Runnable r3 = new Runnable() {
        @Override
        public void run() {
            try{
                Thread.sleep(1000);
                System.out.println("r3 run");
                countDown.countDown();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    };
 
    public static void main(String[] args) throws  Exception{
        System.out.println("===begin=====");
        ExecutorService exec = Executors.newFixedThreadPool(3);
        exec.submit(r1);
        exec.submit(r2);
        exec.submit(r3);
 
        //等待检查，等待三个线程都执行完成后，主线程才能继续执行
        countDown.await();
 
        System.out.println("====end=====");
        exec.shutdown();
    }
}

打印结果

===begin=====
r1 run
r3 run
r2 run
====end=====

在实时系统中的使用场景

1. 实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。例如，我们想测试一个单例类。如果我们创建一个初始计数器为1的CountDownLatch，并让其他所有线程都在这个锁上等待，只需要调用一次countDown()方法就可以让其他所有等待的线程同时恢复执行。
2. 开始执行前等待N个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统都已经启动和运行了。
3. 死锁检测：一个非常方便的使用场景是你用N个线程去访问共享资源，在每个测试阶段线程数量不同，并尝试产生死锁。

应用实例：

1、latch.await()设置等待时间，无需等待子任务完成

public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(10);
 
        for (int i=0; i<9; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " 运行");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        latch.countDown();
                    }
                }
            }).start();
        }
 
        System.out.println("等待子线程运行结束");
        latch.await(10, TimeUnit.SECONDS);
        System.out.println("子线程运行结束");
}

结果打印

等待子线程运行结束
Thread-0 运行
Thread-4 运行
Thread-3 运行
Thread-2 运行
Thread-1 运行
Thread-5 运行
Thread-6 运行
Thread-8 运行
Thread-7 运行
Thread-1 子任务运行结束 2021-02-01T16:02:53.672
Thread-4 子任务运行结束 2021-02-01T16:02:53.672
Thread-0 子任务运行结束 2021-02-01T16:02:53.672
Thread-6 子任务运行结束 2021-02-01T16:02:53.672
Thread-3 子任务运行结束 2021-02-01T16:02:53.672
Thread-2 子任务运行结束 2021-02-01T16:02:53.672
Thread-8 子任务运行结束 2021-02-01T16:02:53.672
Thread-5 子任务运行结束 2021-02-01T16:02:53.672
Thread-7 子任务运行结束 2021-02-01T16:02:53.672
子线程运行结束 2021-02-01T16:03:00.553

改为一秒后：

latch.await(1, TimeUnit.SECONDS);

等待子线程运行结束
Thread-0 运行
Thread-2 运行
Thread-3 运行
Thread-1 运行
Thread-4 运行
Thread-5 运行
Thread-6 运行
Thread-7 运行
Thread-8 运行
子线程运行结束 2021-02-01T16:04:31.890
Thread-0 子任务运行结束 2021-02-01T16:04:33.820
Thread-2 子任务运行结束 2021-02-01T16:04:33.820
Thread-3 子任务运行结束 2021-02-01T16:04:33.820
Thread-1 子任务运行结束 2021-02-01T16:04:33.821
Thread-4 子任务运行结束 2021-02-01T16:04:33.821
Thread-7 子任务运行结束 2021-02-01T16:04:33.821
Thread-5 子任务运行结束 2021-02-01T16:04:33.821
Thread-6 子任务运行结束 2021-02-01T16:04:33.821
Thread-8 子任务运行结束 2021-02-01T16:04:33.821

2、子线程等待主线程处理完毕开始处理，子线程处理完毕后，主线程输出

public static void main(String[] args) throws InterruptedException {
    CountDownLatch countDownLatch = new CountDownLatch(1);
    CountDownLatch await = new CountDownLatch(5);

    for (int i=0; i< 5; i++) {
        new Thread(() -> {
                try {
                    countDownLatch.await();
                    System.out.println("子线程" +Thread.currentThread().getName()+ "处理自己事情");
                    Thread.sleep(1000);
                    await.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
    }

    System.out.println("主线程处理自己事情");
    Thread.sleep(3000);
    countDownLatch.countDown();
    System.out.println("主线程处理结束");
    await.await();
    System.out.println("子线程处理完毕啦");
}

结果打印

主线程处理自己事情
主线程处理结束
子线程Thread-2处理自己事情
子线程Thread-1处理自己事情
子线程Thread-0处理自己事情
子线程Thread-4处理自己事情
子线程Thread-3处理自己事情
子线程处理完毕啦