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

于 2024-05-12 03:21:56 发布
阅读量763 收藏 19
点赞数 7
分类专栏： 程序员 文章标签： java 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84688608/article/details/138738215
版权

读者福利

秋招我借这份PDF的复习思路，收获美团，小米，京东等Java岗offer

更多笔记分享

秋招我借这份PDF的复习思路，收获美团，小米，京东等Java岗offer

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

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

  1. 介绍CountDownLatch及使用场景

  2. 提供几个示例介绍CountDownLatch的使用

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

假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要统计解析总耗时。分析一下：解析每个sheet耗时可能不一样，总耗时就是最长耗时的那个操作。

我们能够想到的最简单的做法是使用join，代码如下：

package com.itsoku.chat13;

import java.util.concurrent.TimeUnit;

/**

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

*/

public class Demo1 {

public static class T extends Thread {

//休眠时间（秒）

int sleepSeconds;

public T(String name, int sleepSeconds) {

super(name);

this.sleepSeconds = sleepSeconds;

}

@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();

}

long endTime = System.currentTimeMillis();

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

}

}

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

long starTime = System.currentTimeMillis();

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

t1.start();

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

t2.start();

t1.join();

t2.join();

long endTime = System.currentTimeMillis();

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

}

}

输出：

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使用步骤：

  1. 创建CountDownLatch对象

  2. 调用其实例方法 await()，让当前线程等待

  3. 调用 countDown()方法，让计数器减1

  4. 当计数器变为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 {

最后

对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。

整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

再分享一波我的Java面试真题+视频学习详解+技能进阶书籍

美团二面惜败，我的凉经复盘（附学习笔记+面试整理+进阶书籍）

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

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

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

}

}

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

最后

对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。

整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

再分享一波我的Java面试真题+视频学习详解+技能进阶书籍

[外链图片转存中…(img-alnOWseG-1715455293779)]

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

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

2401_84688608
关注
专栏目录
【高并发】JUC中等待多线程完成的工具类CountDownLatch
九师兄
11-27 428
添加链接描述假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要统计解析总耗时。分析一下：解析每个sheet耗时可能不一样，总耗时就是最长耗时的那个操作。//休眠时间（秒） int sleepSeconds;System . out . println(startTime + "," + ct . getName() + ",开始处理!");try {
java高并发系列 - 第16天：JUC中等待多线程完成的工具类CountDownLatch，必备技能
最新发布
专搞技术的小兔子
08-07 152
CountDownLatch称之为闭锁，它可以使一个或一批线程在闭锁上等待，等到其他线程执行完相应操作后，闭锁打开，这些等待的线程才可以继续执行。确切的说，闭锁在内部维护了一个倒计数器。通过该计数器的值来决定闭锁的状态，从而决定是否允许等待的线程继续执行。常用方法：public CountDownLatch(int count)：构造方法，count表示计数器的值，不能小于0，否者会报异常。
java高并发系列 - 第16天：JUC中等待多线程完成的工具类CountDownLatch，必备技能...
a502297457760202的博客
07-22 399
这是java高并发系列第16篇文章。 本篇内容 介绍CountDownLatch及使用场景 提供几个示例介绍CountDownLatch的使用 手写一个并行处理任务的工具类 假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要统计解析总耗时。分析一下：解析每个she...
java高并发系列 - 第1天：必须知道的几个概念
路人甲Java
07-05 1142
接下来一个月，咱们一起啃下java高并发，欢迎留言打卡，一起坚持一个月，拿下java高并发。同步（Synchronous）和异步（Asynchronous）同步和异步通常...
java高并发系列 - 第2天：并发级别
路人甲Java
07-06 878
这是java高并发系列第2篇文章，一个月，咱们一起啃下java高并发，欢迎留言打卡，一起坚持一个月，拿下java高并发。由于临界区的存在，多线程之间的并发必须受到控制。根...
java并发编程学习juc工具类之CountDownLatch
weixin_42213903的博客
10-16 194
CountDownLatch是什么？ CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。 例 如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执 行。 CountDownLatch如何工作？ CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当 一个线程完成了自己的任务后，计数器的值就会减1。当计数器值...
java高并发源码-java-concurrent:Java高并发，JUC，相关源码。1、马士兵高并发视频源码（听课时练习）
05-24
JUC，全称Java Util Concurrency，是Java平台标准版（Java SE）的一部分，提供了丰富的并发工具类，用于构建高效、可扩展的多线程应用。 首先，我们来了解下Java并发编程的基础知识。在Java中，多线程主要通过...
JUC代码收集，java高并发多线程学习
03-31
本资源"JUC代码收集，java高并发多线程学习"显然是一个专注于探讨和学习JUC库的资料包。 JUC库包含多个子包，如`concurrent`, `atomic`, `locks`等，每个子包都有其特定的功能和用途： 1. **concurrent**：这是JUC...
java高并发系列 - 第22天：JUC底层工具类Unsafe
专搞技术的小兔子
08-01 314
最近我们一直在学习java高并发，java高并发中主要涉及到类位于java.util.concurrent包中，简称juc，juc中大部分类都是依赖于Unsafe来实现的，主要用到了Unsafe中的CAS、线程挂起、线程恢复等相关功能。所以如果打算深入了解JUC原理的，必须先了解一下Unsafe类。先上一幅Unsafe类的功能图：
Java高并发系列(一)——概念篇
简简单单记录
03-29 406
开篇时间：2020-03-28 完篇时间：······ 一、并发基础概念 同步&异步 同步方法：一旦开始调用同步方法，调用者必须等到方法调用得到结果后才能返回，之后才能进行下一个动作。 异步方法：异步方法开始之后，方法调用会立刻返回，不用等到方法结果返回即可继续进行下一个动作。等到异步调用真正完成且需要用到结果时，则会通知调用者。 并发&并行 并发（concurren...
java中等待所有线程都执行结束（转）
weixin_33883178的博客
06-01 131
转自：http://blog.csdn.net/liweisnake/article/details/12966761    今天看到一篇文章，是关于java中如何等待所有线程都执行结束，文章总结得很好，原文如下http://software.intel.com/zh-cn/blogs/2013/10/15/java-countdownlatchcyclicbarrier/?utm_campaig...
java并发 知乎_Java高并发系列—入门
weixin_36202273的博客
02-12 133
什么是线程在了解什么是「线程」之前，我们先了解一下什么是「进程」进程是线程的母亲，进程是系统进行资源分配和调度的基本单位，是操作系统结构的基础。进程是线程的容器，进程中可以容纳多个线程。简单来讲就是：一间房子相当于一个容器，也就是进程的概念。这间房子住着你和你的父母，三个人就是分别的线程。你上学，妈妈干家务，爸爸上班，做着不同的事情，维持的进程的运行。 「线程」就是轻量级的进程，是程序执行的最小单...
【Java高并发系列】之走进并发世界
Cbuc丶的博客
08-02 223
大家好，我是小菜，一个渴望在互联网行业做到蔡不菜的小菜。可柔可刚，点赞则柔，白嫖则刚！ 死鬼~看完记得给我来个三连哦！ 本文主要介绍 Java并行的入门 如有需要，可以参考 如有帮助，不忘 点赞 ❥ 忘掉那该死的并行 在2014年底的 Avoiding ping pong论坛上，Linus Torvalds 提出了一个截然不同的观点，他说：***“忘掉那该死的并行把！”*** （原文： Give it up . The whole “parallel computing is the future”
Java 高并发系列2-并发锁
samuelnotes的专栏
07-06 8409
Java 高并发系列2-并发锁 接着上一篇并发文章我们继续 Java 高并发系列1-开篇 本篇的主要内容是以下几点： wait 、notify 的简单使用 Reentrantlock的简单使用 synchronized 与Reentrantlock的区别 ThreadLocal的简单使用 看一个面试题： 曾经的面试题：（淘宝？） 实现一个容器，提供两个方法，add，size 写两个线程，线程1...
Juc工具类CountDownLatch闭锁
qq_43193797的博客
04-05 144
/** * * @Description: *让一些线程阻塞直到另一些线程完成一系列操作后才被唤醒。 * * CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。 * 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)， * ...
【Java高并发系列】之入门篇
Cbuc丶的博客
07-25 186
大家好，我是小菜，一个渴望在互联网行业做到蔡不菜的小菜。可柔可刚，点赞则柔，白嫖则刚！ 死鬼~看完记得给我来个三连哦！ 本文主要介绍 Java并行程序基础 如有需要，可以参考 如有帮助，不忘 点赞 ❥ 什么是线程 在了解什么是线程之前，我们先了解一下什么是进程 进程是线程的母亲，进程是系统进行资源分配和调度的基本单位，是操作系统结构的基础。进程是线程的容器，进程中可以容纳多个线程。 简单来讲就是：一间房子相当于一个容器，也就是进程的概念。这间房子住着你和你的父母，三个人就是分别的线程。你上学，妈妈干家务
Java高并发系列3 -再写单例
samuelnotes的专栏
07-08 7306
Java高并发系列3 -再写单例 接高并发系列上一篇Java高并发系列2-并发锁 这篇我们来说说高并发下的单例。 单例模式是最常用到的设计模式之一，熟悉设计模式的朋友对单例模式都不会陌生。非线程安全的单例设计这里不再提及，主要涉及线程安全的单例设计。 1. 看一条设计 public class Singleton { private static Singleton sin=new Sin...
java高并发系列 - 第18天：JAVA线程池，这一篇就够了
路人甲Java
07-29 850
这是java高并发系列第18篇文章。本文主要内容什么是线程池线程池实现原理线程池中常见的各种队列自定义线程创建的工厂常见的饱和策略自定义饱和策略线程池中两种关闭方法有何不...
使用 “CountDownLatch” 实现主线程等待子线程执行完毕
weixin_43466083的博客
11-09 858
线程从开始到结束，都会有些比较耗时的操作，例如在多线程场景中，往往主线程执行结束了，子线程还没执行完毕那么子线程的任务结果是不会返回，只能返回主线程所操作的任务，下面我们给 出几种主线程等待子线程执行结束在返回的操作。 先看看正常执行的顺序：主线程开始-》主线程结束-》子线程开始-》子线程结束 直接就把主线程跑完了 一、使用 join（）方法 下面我们使用join()来看看执行的顺序：主线程开始-》子线程开始-》子线程结束-》主线程结束 public static void main(String[]
Java并发编程详解：JUC工具包与多线程实战
在Java中，JUC库提供了一系列工具，如ThreadPoolExecutor、Semaphore、CyclicBarrier和CountDownLatch等，帮助开发者有效地管理和协调并发任务，确保程序的正确性和性能。 并发编程的学习不仅仅是理论知识，还需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值