CountDownLatch和Join的使用实例以及比较

最新推荐文章于 2024-01-21 18:49:02 发布
原创 最新推荐文章于 2024-01-21 18:49:02 发布 · 704 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#线程

本文对比分析了CountDownLatch和Join在多线程控制中的不同应用，CountDownLatch支持更灵活的阶段控制，允许线程在部分任务完成时继续，而Join则确保所有子线程完全结束后主线程才继续。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

CountDownLatch和Join都可以让一个线程等待子线程完成的功能，但CountDownLatch比Join的优势在哪呢？下面用示例说明

一、首先举一个Join的使用实例，当然Logger需要自己配置

先是Join类
JoinClass

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class JoinClass extends Thread{
    final Logger logger = LoggerFactory.getLogger(JoinClass.class);
    String name;
    JoinClass(String _name) {
        name = _name;
    }
    @Override
    public void run() {
        try {
            logger.info("{} is running",name);
            Thread.sleep(2000);
            logger.info("{} is over",name);
        }catch (InterruptedException e) {
            logger.error("{} , ",name,e);
        }
    }
}

测试方法
Test

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.concurrent.CountDownLatch;
 
public class Test {
    final static Logger logger = LoggerFactory.getLogger(Main.class);
 
    public void JoinClassTest() {
        //join类示例
        JoinClass j1 = new JoinClass("j1");
        JoinClass j2 = new JoinClass("j2");
        JoinClass j3 = new JoinClass("j3");
        j1.start();
        j2.start();
        try {
            j1.join();
            j2.join();
        }catch (InterruptedException e) {
            logger.error("j1 and j2,",e);
        }
        logger.info("j1 and j2 are over, j3 start");
        j3.start();
    }
}

结果
2018-12-03 20:03:39 INFO [CountDownLatchAndJoin.JoinClass] j1 is running
2018-12-03 20:03:39 INFO [CountDownLatchAndJoin.JoinClass] j2 is running
2018-12-03 20:03:41 INFO [CountDownLatchAndJoin.JoinClass] j1 is over
2018-12-03 20:03:41 INFO [CountDownLatchAndJoin.JoinClass] j2 is over
2018-12-03 20:03:41 INFO [CountDownLatchAndJoin.Main] j1 and j2 are over, j3 start
2018-12-03 20:03:41 INFO [CountDownLatchAndJoin.JoinClass] j3 is running
2018-12-03 20:03:43 INFO [CountDownLatchAndJoin.JoinClass] j3 is over

从结果看出使用Join后，主线程在等待 j1 和 j2 执行完成后才去调用 j3线程

二、下面是CountDownLatch使用用例

CountDownLatchSimple类
CountDownLatchClass

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.concurrent.CountDownLatch;
 
public class CountDownLatchSimple extends Thread{
    final Logger logger = LoggerFactory.getLogger(CountDownLatchSimple.class);
    private CountDownLatch countDownLatch;
    String name;
    CountDownLatchSimple(String _name, CountDownLatch _countDownLatch) {
        name = _name;
        countDownLatch=_countDownLatch;
    }
    @Override
    public void run() {
        try {
            logger.info("{} is running",name);
            Thread.sleep(2000);
            logger.info("{} is over",name);
            countDownLatch.countDown();
        }catch (InterruptedException e) {
            logger.info("{}",name,e);
        }
    }
}

测试方法
Test

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.concurrent.CountDownLatch;
 
public class Test {
    final static Logger logger = LoggerFactory.getLogger(Main.class);
 
 
    public void CountDownLatchSimple() {
    //CountDownLatch实现
    CountDownLatch countDownLatch = new CountDownLatch(2);
    CountDownLatchSimple countDownLatch1 = new CountDownLatchSimple("countDownLatch1",countDownLatch);
    CountDownLatchSimple countDownLatch2 = new CountDownLatchSimple("countDownLatch2",countDownLatch);
    CountDownLatchSimple countDownLatch3 = new CountDownLatchSimple("countDownLatch3",countDownLatch);
    countDownLatch1.start();
    countDownLatch2.start();
    try {
        countDownLatch.await();
    }catch (InterruptedException e) {
        logger.error("countDownLatch.await,",e);
    }
    countDownLatch3.start();
    }
}

测试结果

2018-12-03 20:15:43 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatch2 is running
2018-12-03 20:15:43 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatch1 is running
2018-12-03 20:15:45 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatch1 is over
2018-12-03 20:15:45 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatch2 is over
2018-12-03 20:15:45 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatch3 is running
2018-12-03 20:15:47 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatch3 is over

从结果看出CountDownLatch实现了和Join一样的功能

三、但有些功能是否是Join不能实现的呢？看如下代码

CountDownLatchStage类
CountDownLatchStage

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.concurrent.CountDownLatch;
 
public class CountDownLatchStage extends Thread{
    final Logger logger = LoggerFactory.getLogger(CountDownLatchSimple.class);
    private CountDownLatch countDownLatch;
    String name;
    CountDownLatchStage(String _name, CountDownLatch _countDownLatch) {
        name = _name;
        countDownLatch=_countDownLatch;
    }
    @Override
    public void run() {
        try {
            logger.info("{} is running",name);
            Thread.sleep(2000);
            logger.info("{}'s finished half of work ",name);
            countDownLatch.countDown();
            Thread.sleep(1000);
            logger.info("{}'s is over,end",name);
        }catch (InterruptedException e) {
            logger.info("{}",name,e);
        }
    }
}

Test类
Test

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.concurrent.CountDownLatch;
 
public class Test {
    final static Logger logger = LoggerFactory.getLogger(Main.class);  
    public void CountDownLatchStage() {
    //CountDownLatchStage实现
    CountDownLatch countDownLatch = new CountDownLatch(2);
    CountDownLatchStage countDownLatchStage1 = new CountDownLatchStage("countDownLatchStage1",countDownLatch);
    CountDownLatchStage countDownLatchStage2 = new CountDownLatchStage("countDownLatchStage2",countDownLatch);
    CountDownLatchStage countDownLatchStage3 = new CountDownLatchStage("countDownLatchStage3",countDownLatch);
    countDownLatchStage1.start();
    countDownLatchStage2.start();
    try {
        countDownLatch.await();
    }catch (InterruptedException e) {
        logger.error("countDownLatch.await,",e);
    }
    countDownLatchStage3.start();
    }
}

结果
2018-12-03 20:20:50 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage2 is running
2018-12-03 20:20:50 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage1 is running
2018-12-03 20:20:52 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage2’s finished half of work
2018-12-03 20:20:52 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage1’s finished half of work
2018-12-03 20:20:52 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage3 is running
2018-12-03 20:20:53 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage2’s is over,end
2018-12-03 20:20:53 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage1’s is over,end
2018-12-03 20:20:54 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage3’s finished half of work
2018-12-03 20:20:55 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage3’s is over,end

从结果看出CountDownLatch可以让线程在某一阶段受它限制，一个线程执行必须依赖CountDownLatch管理的线程的执行完毕才行。

而Join则没有这种功能，它必须让子线程执行完毕，才能让接下来的程序执行。但相对的，join代码写起来也相对简洁，明了。

四、最后，突然想到用CountDownLatch实现类似CyclicBarrier的功能，就是让所有任务都执行完，才进行下一阶段。类似一群羊在跑时，设置一个栅栏，等所有羊都到齐才开栅栏一样。

CountDownLatchThreeStage类
CountDownLatchThreeStage

package CountDownLatchAndJoin;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.concurrent.CountDownLatch;
 
public class CountDownLatchThreeStage extends Thread{
    final Logger logger = LoggerFactory.getLogger(CountDownLatchSimple.class);
    private CountDownLatch countDownLatch1;
    private CountDownLatch countDownLatch2;
    String name;
    CountDownLatchThreeStage(String _name, CountDownLatch _countDownLatch1,CountDownLatch _countDownLatch2) {
        name = _name;
        countDownLatch1=_countDownLatch1;
        countDownLatch2=_countDownLatch2;
    }
    @Override
    public void run() {
        try {
            logger.info("{}'s stage1...",name);
            Thread.sleep(2000);
            countDownLatch1.countDown();
            logger.info("{}'s stage2...",name);
            Thread.sleep(2000);
            countDownLatch2.countDown();
            Thread.sleep(1000);
            logger.info("{}'s stage3...",name);
        }catch (InterruptedException e) {
            logger.info("{}",name,e);
        }
    }
}

Test类
Test

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.concurrent.CountDownLatch;
 
public class Test {
    final static Logger logger = LoggerFactory.getLogger(Main.class);
    public void CountDownLatchThreeTasksStage() {
    //CountDownLatch 多任务同时进入下一阶段，很low，要用Cyclicbarrier
        CountDownLatch countDownLatch1 = new CountDownLatch(2);
        CountDownLatch countDownLatch2 = new CountDownLatch(2);
        CountDownLatchThreeStage countDownLatchStage1 = new CountDownLatchThreeStage("countDownLatchStage1",countDownLatch1,countDownLatch2);
        CountDownLatchThreeStage countDownLatchStage2 = new CountDownLatchThreeStage("countDownLatchStage2",countDownLatch1,countDownLatch2);
        countDownLatchStage1.start();
        countDownLatchStage2.start();
        try {
            countDownLatch1.await();
            countDownLatch2.await();
        }catch (InterruptedException e) {
            logger.error("countDownLatch.await,",e);
        }
    }
}

结果
2018-12-03 20:41:01 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage2’s stage1…
2018-12-03 20:41:01 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage1’s stage1…
2018-12-03 20:41:03 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage1’s stage2…
2018-12-03 20:41:03 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage2’s stage2…
2018-12-03 20:41:06 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage1’s stage3…
2018-12-03 20:41:06 INFO [CountDownLatchAndJoin.CountDownLatchSimple] countDownLatchStage2’s stage3…

当然，这里只是举例。在实用中还是要用CyclicBarrier来让所有任务完成才进入下一阶段。

CountDownLatch实例一
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
10-24 941
import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; public class CountDownLatchExample { public static void main(String[] args) throws InterruptedException { ...
CountDownLatch的使用场景和代码实例
litlit023的专栏
10-14 290
参考地址： https://www.jb51.net/article/138726.htm https://zhuanlan.zhihu.com/p/100574357
并发编程大师系列之：CountDownLatch和Join
weixin_30682127的博客
05-25 126
业务场景描述：假设一条流水线上有三个工作者：worker1，worker2，worker3。有一个任务的完成需要他们三者协作完成，worker3可以开始这个任务的前提是worker1和worker2完成了他们的工作，而worker1和worker2是可以并行他们各自的工作的。 1.join实现 public class CountDownLatchAndJoin { publ...
CountDownLatch与join
qq_34785454的博客
04-03 296
CountDownLatch是《java并发编程实战》这本书里讲的同步工具类的第一种，闭锁的一种实现。直接先上模拟代码： import java.util.concurrent.CountDownLatch; public class CountDownLatchTest { public static void main(String[] args) throws InterruptedE...
CountDownLatch理解一：与join的区别
热门推荐
09-17 2万+
首先，我们来看一个应用场景1： 假设一条流水线上有三个工作者：worker0，worker1，worker2。有一个任务的完成需要他们三者协作完成，worker2可以开始这个任务的前提是worker0和worker1完成了他们的工作，而worker0和worker1是可以并行他们各自的工作的。 如果我们要编码模拟上面的场景的话，我们大概很容易就会想到可以用join来做。当在当前线程中调用某个线
多线程CountDownLatch和Join
weixin_30814329的博客
03-04 219
如果现在有五个线程A、B、C、D、E，请问如何用E线程用于统计A、B、C、D四个线程的结果？ 题意需要用E线程统计A、B、C、D四个线程，也就是说E线程必须要等到前面四个线程运行结束之后才能执行。那么如何使用E线程来统计前面四个线程的结果呢？ 下面介绍两种实现方法： 一、CountDownLatch CountDownLatch是一种java.util.concurrent包下一个同步工具...
countDownLatch和join有什么区别
最新发布
07-24
而 `CountDownLatch` 可以很容易地与线程池配合使用，只需要将 `CountDownLatch` 实例传递给任务，在任务完成时调用 `countDown()` 即可。 6. 控制粒度： - `join()` 必须等待线程完全执行完毕。 - `...
Java并发编程|用join和CountDownLatch、CyclicBarrier实现主线程等待子线程
weixin_39452419的博客
01-21 451
在redis运维开发中，有一个功能是：获取redis集群某一天内多个实例的日志，并将这些日志汇总后按时间顺序展示。在上述需求中，“获取redis集群在一天内多个实例的日志”这一步骤是比较耗时的，需要将远程服务器上的日志读取到内存中。但从每个redis实例中获取日志的动作都是独立的，可以考虑使用多线程，每个线程读取一个redis实例的日志。等所有线程完成日志读取之后再汇总和排序。。
CountDownLatch和completablefuture怎么结合使用
03-08
### CountDownLatch 结合 CompletableFuture 使用方法 在 Java 并发编程中，`CountDownLatch` 和 `CompletableFuture` 可以很好地结合起来处理复杂的并发场景。下面是一个具体的例子说明如何将两者结合使用。 ####...
java 中Thread.join()的使用方法
08-30
在`Domino`类的`run()`方法中，每个线程调用`thread.join()`，这里的`thread`就是前一个线程的引用，这样就确保了当前线程（比如`Domino`线程）会等待前一个线程（比如`Domino`线程的上一个实例）结束后再执行`...
CountDownLatch的理解和使用
秃头的博客
07-06 412
CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。 CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。
CountDownLatch和join()的使用
qianye的博客
08-25 478
CountDownLatch 概念 CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。 CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。可以解决当一个某线程任务需要依赖其
CountdownLatch和Join
weixin_47188125的博客
09-23 312
join()方法是Thread类中的一个方法，该方法的定义是等待该线程终止。其实就是join()方法将挂起调用线程的执行，直到被调用的对象完成它的执行。
CountDownLatch使用示例
weixin_37961450的博客
07-20 248
public void countDown() 递减锁存器的计数，如果计数到达零，则释放所有等待的线程。如果当前计数大于零，则将计数减少. public boolean await(long timeout,TimeUnit unit) throws InterruptedException 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。如果当前计数为零，则此方法立刻返回true值。 /* * 主线程计数器只有1 countdown将计数器降为0，释放所有等待线
CountDownLatch的使用示例
weixin_44582927的博客
07-01 259
CountDownLatch基于计数器的思想,对线程的执行流程进行控制,一般用于多个任务都完成才可进行下一步的情况. 上代码: public static void main(String[] args) { /** * 创建 CountDownLatch 并指定计数器的值为3 */ CountDownLatch countDownLatch = new CountDownLatch(3); ThreadPool...
CountDownLatch简单例子
12-06 231
public class CountDownLatchDemo { public static void main(String[] args) { CountDownLatch countDownLatch = new CountDownLatch(2); new Thre...
CountDownLatch的简单示例
未来编程
03-07 376
CountDownLatch有3个主要方法：1. 构造方法：定义计数器数量2. countDown()：计数器减一3. await()：阻塞当前线程直到计数器为0时，唤醒所有线程模拟多并发场景：定义一个CountDownLatch，每启动一个线程后让线程wait。等所有线程启动完毕后，执行每个线程的countDown直到计数器为0，此时所有线程同时执行。public class LocalVari...
CountDownLatch 的使用案例
crazy的博客
01-28 447
import java.util.Arrays; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import java.util.stream.IntStream; import static java.util.stream.Collectors.toList; import static java.util.concurrent.Thr..
CountDownLatch用例及源码解析
犀利的代码总是很精炼
10-09 166
[align=center]CountDownLatch[/align] 官法解释:一个对同步有帮助的类，它允许一个或多个线程等待只到这组操作在其他线程全部完成. 官司用法:初始是由一个给定的count，await方法可以阻塞只到当前count到达0.这是一个自减机制，比如你初始化 count为5,每调用一次countDown，就减1,只到为0,才释放所有线程，但是这种门插锁机制只有一次有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值