CountDownLatch快速上手指南

讲什么

CountDownLatch是什么、数据结构、说明、api方法、示例

作用:使一个或者多个线程等待其他线程执行完后再操作.

数据结构:计数器+阻塞队列.

说明:

• 计数器>0,阻塞队列的线程都会被挂起
• 计数器=0,阻塞队列中的线程都会被唤醒.
• 这里说的阻塞队列中的线程指的就是等待其他线程执行完的队列.

Api方法：

• CountDownLatch实例化时构造方法要求传入一个int类型参数作为计数器.
• countDown()方法 使计数器减1.
• await()、await(long,TimeUnit) 方法使主线程加入阻塞队列 等待子线程执行完成.

业务场景:串行任务相互结果不影响改为并行任务

比如一个接口中我们会调用外部api3次,结果相互并不依赖 但是最后需要封装起来,此时就可以考虑使用多线程执行任务节省时间.但是出现一个问题 就是不知道3个线程何时执行完毕进行数据封装.最简单的办法是使用join方法 让封装数据的主线程等待3个线程的执行结果.起原理是会不断循环检测 join加入的线程是否存活,如果存活则不断等待下去 否则执行主线程. 当前这里所讲的CountDownLatch比起join方法更加强大 也实现了join的功能.比如可以让多线程等待其他线程执行完后再操作.

示例代码

package com.example.springboot.concurrent;

import java.util.HashMap;
import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) {
        //结果汇总
        HashMap<String, Long> map = new HashMap<>();
        //主线程等待其他线程执行后结束
        CountDownLatch countDownLatch = new CountDownLatch(4);


        //时间统计
        Long startTime = System.currentTimeMillis();
        System.out.println("开始时间" + startTime);

        //子线程
        Thread userCount = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("用户统计");
                    Thread.sleep(3000L);
                    map.put("用户统计", 1L);
                    //任务执行完 计数器-1
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread askCount = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("问诊统计");
                    Thread.sleep(3000L);
                    map.put("问诊统计", 1L);
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });


        Thread orderCount = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("订单统计");
                    Thread.sleep(3000L);
                    map.put("订单统计", 1L);
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });


        Thread payCount = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("支付统计");
                    Thread.sleep(3000L);
                    map.put("支付统计", 4L);
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        //启动子线程开启任务
        userCount.start();
        askCount.start();
        orderCount.start();
        payCount.start();
        


        //主线程
        try {
            countDownLatch.await();
            Long endTime = System.currentTimeMillis();
            System.out.println("结束时间" + endTime);
            System.out.println("执行时间" + (endTime - startTime) / 1000 + "秒");
            System.out.println("执行结果" + map.toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}