突击并发编程JUC系列-并发工具 CountDownLatch

> 突击并发编程JUC系列演示代码地址：
> https://github.com/mtcarpenter/JavaTutorial

小伙伴们，大家好，我们又见面了，突击并发编程JUC系列实战并发工具发车了。新的章节还是新的故事讲解，不知各位小伙伴们在面试遇到CountDownLatch、CyclicBarrier、Semaphore和Exchanger工具类灵魂拷问。本章节提供一种并发流程控制的手段CountDownLatch。

基本介绍

CountDownLatch允许一个或多个线程等待其他线程完成操作。在日常开发中经常会遇到需要在主线程中开启多个线程去并行执行任务，并且主线程需要等待所有子线程执行完毕后再进行汇总的场景。在CountDownLatch出现之前一般都使用线程的join()方法来实现这一点，但是join()方法不够灵活，不能够满足不同场景的需要。使用JDK 了一系列的并发流程控制手段类，会使代码更加优雅。
使用 join 等待一系列操作完成的代码可能如下：

// 一个线程 等待
thread.join();
// 多个线程 等待
for (Thread thread : list) {
      thread.join();
}

CountdownLatch 运行流程图

如流程图 CountDownLatch 初始值为 3 ， 首先线程会调用 await 方法，当前数量大于0 线程进行阻塞等待，T1、 T2 、T3 每一次调用countDown 方法，计数器减少 1 ，计数器为 0 的时候，阻塞的线程 TA 将放行，执行剩余操作。

听故事学技术

一年一度的植树节，到来了，新日小学为了响应国家植树绿化的号召，举办了人人参与的”护城小卫士植树活动“，神兽们早早来到了教室，在出发之后每一个班主任都在教室给大家讲解植树相关的安全知识，和此次活动目的。所有的神兽等待铃声响起，神兽们他们整齐划一的去操场集合，如下案例：

public class CountDownLatchExample1 {

    private final static int gradeNum = 6;

    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newScheduledThreadPool(gradeNum);
        // 铃声信号
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < gradeNum; i++) {
            int gradeName = i + 1;
            exec.submit(() -> {
                try {
                    countDownLatch.await();
                    wait(gradeName);

                } catch (Exception e) {
                }
            });
        }
        // 3 秒之后开启 通知
        TimeUnit.SECONDS.sleep(3);
        System.out.println("通知、通知，请全体同学速来操场集合.....");
        countDownLatch.countDown();

        exec.shutdown();
    }

    private static void wait(int gradeName) throws Exception {
        TimeUnit.MILLISECONDS.sleep((int) Math.random() * 1000);
        System.out.println(gradeName + "年级所有同学到达操场");
    }
}

此段代码六个线程（班级）全部阻塞，主线程等待 3 秒执行 countDownLatch.countDown() ，计数器减 1 ，此时的countDownLatch 为 0， 所有countDownLatch.await() 收到为 0 的信号不再阻塞，继续执行接下来的任务。
运行结果如下：

通知、通知，请全体同学速来操场集合.....
4年级所有同学到达操场
1年级所有同学到达操场
6年级所有同学到达操场
2年级所有同学到达操场
3年级所有同学到达操场
5年级所有同学到达操场

主线程等待子线程完成

领导发话这次活动以年级为单位在操场集合，每一个年级人数不一致，整理花费的时间也不一致，每一个整理好的班级报道给领导，领导等待六个年级全部整理完成，统一打开校门出发。通过 CountDownLatch实现案例如下：

public class CountDownLatchExample2 {
    private final static int gradeNum = 6;
    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newScheduledThreadPool(gradeNum);
        final CountDownLatch countDownLatch = new CountDownLatch(gradeNum);
        for (int i = 0; i < gradeNum; i++) {
            int gradeName = i + 1;
            exec.submit(() -> {
                try {
                    wait(gradeName);
                } catch (Exception e) {
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        System.out.println("等待所有年级集合准备.....");
        countDownLatch.await();
        System.out.println("所有年级准备好了，出发.........");
        exec.shutdown();
    }
    private static void wait(int gradeName) throws Exception {
        TimeUnit.MILLISECONDS.sleep((int) Math.random() * 1000);
        System.out.println(gradeName + "年级已经准备好了");
    }
}

首先我们通过newScheduledThreadPool(gradeNum) 创建了六个线程池，每一个线程池代表一个班级，CountDownLatch(gradeNum) 表示我们需要计数的数量，这里我需要等待六个班级才能执行，TimeUnit.MILLISECONDS.sleep((int) Math.random() * 1000);随机时间，用于表示每一个班级整理的时间。主线程调用countDownLatch.await（）方法后会被阻塞。子线程执行完毕后调用countDownLatch.countDown（）方法让countDownLatch内部的计数器减1，所有子线程执行完毕并调用countDown（）方法后计数器会变为 0，这时候主线程的 await（）方法才会返回。
运行代码如下：

等待所有年级集合准备.....
2年级已经准备好了
5年级已经准备好了
3年级已经准备好了
6年级已经准备好了
1年级已经准备好了
4年级已经准备好了
所有年级准备好了，出发.........

主线程规定时间等待子线程完成

学校的领导规定在 8 点集合出发，当然才去的一年级小朋友，必定没有大哥哥整理速度那么快，导致其他年级都走了，一年级才准备好的场景，代码实现如下：

public class CountDownLatchExample3 {
    private final static int gradeNum = 6;

    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newScheduledThreadPool(gradeNum);
        final CountDownLatch countDownLatch = new CountDownLatch(gradeNum);
        for (int i = 0; i < gradeNum; i++) {
            int gradeName = i + 1;
            exec.submit(() -> {
                try {
                    wait(gradeName);
                } catch (Exception e) {
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        System.out.println("等待所有年级集合准备.....");
        countDownLatch.await(1000, TimeUnit.MILLISECONDS);
        System.out.println("8 点了准备好的年级，先出发.........");
        exec.shutdown();
    }

    private static void wait(int gradeName) throws Exception {
        // 模拟一年级等待时间更长
        if (gradeName == 1) {
            TimeUnit.SECONDS.sleep(2);
        } else {
            TimeUnit.MILLISECONDS.sleep((int) Math.random() * 1000);
        }
        System.out.println(gradeName + "年级已经准备好了");
    }
}

与前面的代码相比，此段代码多了一个countDownLatch.await(1000, TimeUnit.MILLISECONDS);,countDownLatch的 await 可以等待超时时间，如果在规定时间内业务不管有没有完成，主线程都不会被阻塞。
运行结果如下：

等待所有年级集合准备.....
3年级已经准备好了
4年级已经准备好了
2年级已经准备好了
6年级已经准备好了
5年级已经准备好了
8 点了准备好的年级，先出发.........
1年级已经准备好了

** 我是小春哥，从事 Java 后端开发，会一点前端、通过持续输出系列技术文章以文会友，如果本文能为您提供帮助，欢迎大家关注、 点赞、分享支持，我们下期再见！