java高并发系列 - 第16天：JUC中等待多线程完成的工具类CountDownLatch，必备技能

示例1：一个简单的示例

我们使用CountDownLatch来完成上面示例中使用join实现的功能，代码如下：

package com.itsoku.chat13;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;

/**

• 微信公众号：javacode2018，获取年薪50万课程

*/

public class Demo2 {

public static class T extends Thread {

//休眠时间（秒）

int sleepSeconds;

CountDownLatch countDownLatch;

public T(String name, int sleepSeconds, CountDownLatch countDownLatch) {

super(name);

this.sleepSeconds = sleepSeconds;

this.countDownLatch = countDownLatch;

}

@Override

public void run() {

Thread ct = Thread.currentThread();

long startTime = System.currentTimeMillis();

System.out.println(startTime + “,” + ct.getName() + “,开始处理!”);

try {

//模拟耗时操作，休眠sleepSeconds秒

TimeUnit.SECONDS.sleep(this.sleepSeconds);

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

countDownLatch.countDown();

}

long endTime = System.currentTimeMillis();

System.out.println(endTime + “,” + ct.getName() + “,处理完毕,耗时:” + (endTime - startTime));

}

}

public static void main(String[] args) throws InterruptedException {

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “线程 start!”);

CountDownLatch countDownLatch = new CountDownLatch(2);

long starTime = System.currentTimeMillis();

T t1 = new T(“解析sheet1线程”, 2, countDownLatch);

t1.start();

T t2 = new T(“解析sheet2线程”, 5, countDownLatch);

t2.start();

countDownLatch.await();

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “线程 end!”);

long endTime = System.currentTimeMillis();

System.out.println(“总耗时:” + (endTime - starTime));

}

}

输出：

1563767580511,main线程 start!

1563767580513,解析sheet1线程,开始处理!

1563767580513,解析sheet2线程,开始处理!

1563767582515,解析sheet1线程,处理完毕,耗时:2002

1563767585515,解析sheet2线程,处理完毕,耗时:5002

1563767585515,main线程 end!

总耗时:5003

从结果中看出，效果和join实现的效果一样，代码中创建了计数器为2的 CountDownLatch，主线程中调用 countDownLatch.await();会让主线程等待，t1、t2线程中模拟执行耗时操作，最终在finally中调用了 countDownLatch.countDown();,此方法每调用一次，CountDownLatch内部计数器会减1，当计数器变为0的时候，主线程中的await()会返回，然后继续执行。注意：上面的 countDown()这个是必须要执行的方法，所以放在finally中执行。

示例2：等待指定的时间

---

还是上面的示例，2个线程解析2个sheet，主线程等待2个sheet解析完成。主线程说，我等待2秒，你们还是无法处理完成，就不等待了，直接返回。如下代码：

package com.itsoku.chat13;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;

/**

• 微信公众号：javacode2018，获取年薪50万课程

*/

public class Demo3 {

public static class T extends Thread {

//休眠时间（秒）

int sleepSeconds;

CountDownLatch countDownLatch;

public T(String name, int sleepSeconds, CountDownLatch countDownLatch) {

super(name);

this.sleepSeconds = sleepSeconds;

this.countDownLatch = countDownLatch;

}

@Override

public void run() {

Thread ct = Thread.currentThread();

long startTime = System.currentTimeMillis();

System.out.println(startTime + “,” + ct.getName() + “,开始处理!”);

try {

//模拟耗时操作，休眠sleepSeconds秒

TimeUnit.SECONDS.sleep(this.sleepSeconds);

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

countDownLatch.countDown();

}

long endTime = System.currentTimeMillis();

System.out.println(endTime + “,” + ct.getName() + “,处理完毕,耗时:” + (endTime - startTime));

}

}

public static void main(String[] args) throws InterruptedException {

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “线程 start!”);

CountDownLatch countDownLatch = new CountDownLatch(2);

long starTime = System.currentTimeMillis();

T t1 = new T(“解析sheet1线程”, 2, countDownLatch);

t1.start();

T t2 = new T(“解析sheet2线程”, 5, countDownLatch);

t2.start();

boolean result = countDownLatch.await(2, TimeUnit.SECONDS);

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “线程 end!”);

long endTime = System.currentTimeMillis();

System.out.println(“主线程耗时:” + (endTime - starTime) + “,result:” + result);

}

}

输出：

1563767637316,main线程 start!

1563767637320,解析sheet1线程,开始处理!

1563767637320,解析sheet2线程,开始处理!

1563767639321,解析sheet1线程,处理完毕,耗时:2001

1563767639322,main线程 end!

主线程耗时:2004,result:false

1563767642322,解析sheet2线程,处理完毕,耗时:5002

从输出结果中可以看出，线程2耗时了5秒，主线程耗时了2秒，主线程中调用 countDownLatch.await(2,TimeUnit.SECONDS);，表示最多等2秒，不管计数器是否为0，await方法都会返回，若等待时间内，计数器变为0了，立即返回true，否则超时后返回false。

示例3：2个CountDown结合使用的示例

有3个人参见跑步比赛，需要先等指令员发指令枪后才能开跑，所有人都跑完之后，指令员喊一声，大家跑完了。

示例代码：

package com.itsoku.chat13;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;

/**

• 微信公众号：javacode2018，获取年薪50万课程

*/

public class Demo4 {

public static class T extends Thread {

//跑步耗时（秒）

int runCostSeconds;

CountDownLatch commanderCd;

CountDownLatch countDown;

public T(String name, int runCostSeconds, CountDownLatch commanderCd, CountDownLatch countDown) {

super(name);

this.runCostSeconds = runCostSeconds;

this.commanderCd = commanderCd;

this.countDown = countDown;

}

@Override

public void run() {

//等待指令员枪响

try {

commanderCd.await();

} catch (InterruptedException e) {

e.printStackTrace();

}

Thread ct = Thread.currentThread();

long startTime = System.currentTimeMillis();

System.out.println(startTime + “,” + ct.getName() + “,开始跑!”);

try {

//模拟耗时操作，休眠runCostSeconds秒

TimeUnit.SECONDS.sleep(this.runCostSeconds);

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

countDown.countDown();

}

long endTime = System.currentTimeMillis();

System.out.println(endTime + “,” + ct.getName() + “,跑步结束,耗时:” + (endTime - startTime));

}

}

public static void main(String[] args) throws InterruptedException {

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “线程 start!”);

CountDownLatch commanderCd = new CountDownLatch(1);

CountDownLatch countDownLatch = new CountDownLatch(3);

long starTime = System.currentTimeMillis();

T t1 = new T(“小张”, 2, commanderCd, countDownLatch);

t1.start();

T t2 = new T(“小李”, 5, commanderCd, countDownLatch);

t2.start();

T t3 = new T(“路人甲”, 10, commanderCd, countDownLatch);

t3.start();

//主线程休眠5秒,模拟指令员准备发枪耗时操作

TimeUnit.SECONDS.sleep(5);

System.out.println(System.currentTimeMillis() + “,枪响了，大家开始跑”);

commanderCd.countDown();

countDownLatch.await();

long endTime = System.currentTimeMillis();

System.out.println(System.currentTimeMillis() + “,” + Thread.currentThread().getName() + “所有人跑完了，主线程耗时:” + (endTime - starTime));

}

}

输出：

1563767691087,main线程 start!

1563767696092,枪响了，大家开始跑

1563767696092,小张,开始跑!

1563767696092,小李,开始跑!

1563767696092,路人甲,开始跑!

1563767698093,小张,跑步结束,耗时:2001

1563767701093,小李,跑步结束,耗时:5001

1563767706093,路人甲,跑步结束,耗时:10001

1563767706093,main所有人跑完了，主线程耗时:15004

代码中，t1、t2、t3启动之后，都阻塞在 commanderCd.await();，主线程模拟发枪准备操作耗时5秒，然后调用 commanderCd.countDown();模拟发枪操作，此方法被调用以后，阻塞在 commanderCd.await();的3个线程会向下执行。主线程调用 countDownLatch.await();之后进行等待，每个人跑完之后，调用 countDown.countDown();通知一下 countDownLatch让计数器减1，最后3个人都跑完了，主线程从 countDownLatch.await();返回继续向下执行。

手写一个并行处理任务的工具类

package com.itsoku.chat13;

import org.springframework.util.CollectionUtils;

import java.util.List;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

import java.util.function.Consumer;

import java.util.stream.Collectors;

import java.util.stream.Stream;

/**

• 微信公众号：javacode2018，获取年薪50万课程

*/

public class TaskDisposeUtils {

//并行线程数

public static final int POOL_SIZE;

static {

POOL_SIZE = Integer.max(Runtime.getRuntime().availableProcessors(), 5);

}

/**

• 并行处理，并等待结束

• @param taskList 任务列表

• @param consumer 消费者

• @param <T>

• @throws InterruptedException

*/

public static <T> void dispose(List<T> taskList, Consumer<T> consumer) throws InterruptedException {

dispose(true, POOL_SIZE, taskList, consumer);

}

/**

• 并行处理，并等待结束

• @param moreThread 是否多线程执行

• @param poolSize 线程池大小

• @param taskList 任务列表

• @param consumer 消费者

• @param <T>

• @throws InterruptedException

*/

public static <T> void dispose(boolean moreThread, int poolSize, List<T> taskList, Consumer<T> consumer) throws InterruptedException {

if (CollectionUtils.isEmpty(taskList)) {

return;

}

if (moreThread && poolSize > 1) {

poolSize = Math.min(poolSize, taskList.size());

ExecutorService executorService = null;

try {

executorService = Executors.newFixedThreadPool(poolSize);

CountDownLatch countDownLatch = new CountDownLatch(taskList.size());

for (T item : taskList) {

executorService.execute(() -> {

try {

consumer.accept(item);

} finally {

countDownLatch.countDown();

}

});

}

countDownLatch.await();

} finally {

if (executorService != null) {

executorService.shutdown();

}

}

} else {

for (T item : taskList) {

consumer.accept(item);

}

}

}

public static void main(String[] args) throws InterruptedException {

//生成1-10的10个数字，放在list中，相当于10个任务

List<Integer> list = Stream.iterate(1, a -> a + 1).limit(10).collect(Collectors.toList());

//启动多线程处理list中的数据，每个任务休眠时间为list中的数值

TaskDisposeUtils.dispose(list, item -> {

try {

long startTime = System.currentTimeMillis();

TimeUnit.SECONDS.sleep(item);

long endTime = System.currentTimeMillis();

System.out.println(System.currentTimeMillis() + “,任务” + item + “执行完毕，耗时:” + (endTime - startTime));

} catch (InterruptedException e) {

e.printStackTrace();

}

});

//上面所有任务处理完毕完毕之后，程序才能继续

System.out.println(list + “中的任务都处理完毕!”);

}

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

面试难免让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式，就会容易很多。

此外，都说“面试造火箭，工作拧螺丝”，那对于准备面试的朋友，你只需懂一个字：刷！

给我刷刷刷刷，使劲儿刷刷刷刷刷！今天既是来谈面试的，那就必须得来整点面试真题，这不花了我整28天，做了份“Java一线大厂高岗面试题解析合集：JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法等”

且除了单纯的刷题，也得需准备一本【JAVA进阶核心知识手册】：JVM、JAVA集合、JAVA多线程并发、JAVA基础、Spring 原理、微服务、Netty与RPC、网络、日志、Zookeeper、Kafka、RabbitMQ、Hbase、MongoDB、Cassandra、设计模式、负载均衡、数据库、一致性算法、JAVA算法、数据结构、加密算法、分布式缓存、Hadoop、Spark、Storm、YARN、机器学习、云计算，用来查漏补缺最好不过。

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式，就会容易很多。

此外，都说“面试造火箭，工作拧螺丝”，那对于准备面试的朋友，你只需懂一个字：刷！

给我刷刷刷刷，使劲儿刷刷刷刷刷！今天既是来谈面试的，那就必须得来整点面试真题，这不花了我整28天，做了份“Java一线大厂高岗面试题解析合集：JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法等”

[外链图片转存中…(img-PMZ5UOd7-1713498988904)]

且除了单纯的刷题，也得需准备一本【JAVA进阶核心知识手册】：JVM、JAVA集合、JAVA多线程并发、JAVA基础、Spring 原理、微服务、Netty与RPC、网络、日志、Zookeeper、Kafka、RabbitMQ、Hbase、MongoDB、Cassandra、设计模式、负载均衡、数据库、一致性算法、JAVA算法、数据结构、加密算法、分布式缓存、Hadoop、Spark、Storm、YARN、机器学习、云计算，用来查漏补缺最好不过。

[外链图片转存中…(img-cDyxjF7g-1713498988905)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！