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

2401_84688721

于 2024-05-12 03:22:42 发布

阅读量615

点赞数 25

分类专栏：程序员文章标签： java 面试学习

本文链接：https://blog.csdn.net/2401_84688721/article/details/138738226

版权

程序员专栏收录该内容

115 篇文章 0 订阅

订阅专栏

最后

按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。

学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。

“道路是曲折的，前途是光明的！”

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

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

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

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

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

总耗时:5005

代码中启动了2个解析sheet的线程，第一个耗时2秒，第二个耗时5秒，最终结果中总耗时：5秒。上面的关键技术点是线程的 join()方法，此方法会让当前线程等待被调用的线程完成之后才能继续。可以看一下join的源码，内部其实是在synchronized方法中调用了线程的wait方法，最后被调用的线程执行完毕之后，由jvm自动调用其notifyAll()方法，唤醒所有等待中的线程。这个notifyAll()方法是由jvm内部自动调用的，jdk源码中是看不到的，需要看jvm源码，有兴趣的同学可以去查一下。所以JDK不推荐在线程上调用wait、notify、notifyAll方法。

而在JDK1.5之后的并发包中提供的CountDownLatch也可以实现join的这个功能。

CountDownLatch介绍

CountDownLatch称之为闭锁，它可以使一个或一批线程在闭锁上等待，等到其他线程执行完相应操作后，闭锁打开，这些等待的线程才可以继续执行。确切的说，闭锁在内部维护了一个倒计数器。通过该计数器的值来决定闭锁的状态，从而决定是否允许等待的线程继续执行。

常用方法：

public CountDownLatch(int count)：构造方法，count表示计数器的值，不能小于0，否者会报异常。

public void await() throws InterruptedException：调用await()会让当前线程等待，直到计数器为0的时候，方法才会返回，此方法会响应线程中断操作。

public boolean await(long timeout, TimeUnit unit) throws InterruptedException：限时等待，在超时之前，计数器变为了0，方法返回true，否者直到超时，返回false，此方法会响应线程中断操作。

public void countDown()：让计数器减1

CountDownLatch使用步骤：

创建CountDownLatch对象
调用其实例方法 await()，让当前线程等待
调用 countDown()方法，让计数器减1
当计数器变为0的时候， await()方法会返回

示例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;

总结

一般像这样的大企业都有好几轮面试，所以自己一定要花点时间去收集整理一下公司的背景，公司的企业文化，俗话说「知己知彼百战不殆」，不要盲目的去面试，还有很多人关心怎么去跟HR谈薪资。

这边给大家一个建议，如果你的理想薪资是30K，你完全可以跟HR谈33~35K，而不是一下子就把自己的底牌暴露了出来，不过肯定不能说的这么直接，比如原来你的公司是25K，你可以跟HR讲原来的薪资是多少，你们这边能给到我的是多少？你说我这边希望可以有一个20%涨薪。

最后再说几句关于招聘平台的，总之，简历投递给公司之前，请确认下这家公司到底咋样，先去百度了解下，别被坑了，每个平台都有一些居心不良的广告党等着你上钩，千万别上当！！！

Java架构学习资料，学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务高级架构开发等等。

还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书。
在这里插入图片描述

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

，比如原来你的公司是25K，你可以跟HR讲原来的薪资是多少，你们这边能给到我的是多少？你说我这边希望可以有一个20%涨薪。

Java架构学习资料，学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务高级架构开发等等。

还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书。
[外链图片转存中…(img-TmY8p0t5-1715455339928)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

2401_84688721

关注

25
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
java高并发系列 - 第16天：JUC中等待多线程完成的工具类CountDownLatch，必备技能(2)

一般像这样的大企业都有好几轮面试，所以自己一定要花点时间去收集整理一下公司的背景，公司的企业文化，俗话说「知己知彼百战不殆」，不要盲目的去面试，还有很多人关心怎么去跟HR谈薪资。这边给大家一个建议，如果你的理想薪资是30K，你完全可以跟HR谈33~35K，而不是一下子就把自己的底牌暴露了出来，不过肯定不能说的这么直接，比如原来你的公司是25K，你可以跟HR讲原来的薪资是多少，你们这边能给到我的是多少？你说我这边希望可以有一个20%涨薪。
复制链接

扫一扫