业务场景描述:假设一条流水线上有三个工作者:worker1,worker2,worker3。有一个任务的完成需要他们三者协作完成,worker3可以开始这个任务的前提是worker1和worker2完成了他们的工作,而worker1和worker2是可以并行他们各自的工作的。

1.join实现

public class CountDownLatchAndJoin {

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

        // 三个独立的工人线程
worker worker1 = new worker("worker1", (long) (Math.random()*4000));
worker worker2 = new worker("worker2", (long) (Math.random()*4000));
worker worker3 = new worker("worker3", (long) (Math.random()*4000));
// worker worker1 = new worker("worker1", 6000);
// worker worker2 = new worker("worker2", 5000);
// worker worker3 = new worker("worker3", 5000);
worker1.start();
worker2.start(); worker1.join();
worker2.join();
System.out.println("准备工作就绪..."); worker3.start(); } // 工人类
public static class worker extends Thread {
// 名字
private String name;
//工作时间
private long time; worker(String name, long time) {
this.name = name;
this.time = time;
} public void run() {
try {
System.out.println(name + "开始工作");
Thread.sleep(time);
System.out.println(name + "工作完成,耗费时间=" + time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} }

结果:

worker2开始工作
worker1开始工作
worker1工作完成,耗费时间=601
worker2工作完成,耗费时间=2886
准备工作就绪...
worker3开始工作
worker3工作完成,耗费时间=686

可以顺利的完成工作,join的工作原理是,不停检查thread是否存活,如果存活则让当前线程永远wait,直到thread线程终止,线程的notifyAll就会被调用,还可以理解为join就是插队的意思


2.CountDownLatch实现

public class CountDownLatchTest {

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

        // 初始化计数器为2
CountDownLatch countDownLatch = new CountDownLatch(2); // 三个独立的工人线程
worker worker1 = new worker("worker1", (long) (Math.random() * 4000), countDownLatch);
worker worker2 = new worker("worker2", (long) (Math.random() * 4000), countDownLatch);
worker worker3 = new worker("worker3", (long) (Math.random() * 4000), countDownLatch);
worker1.start();
worker2.start(); // 当计数器不为0的时候均等待
countDownLatch.await(); System.out.println("准备工作就绪...");
worker3.start();
} public static class worker extends Thread { private String name;
private long time;
private CountDownLatch countDownLatch; worker(String name, long time, CountDownLatch countDownLatch) {
this.name = name;
this.time = time;
this.countDownLatch = countDownLatch;
} public void run() {
System.out.println(name + " 开始工作了。。。");
// 减一
countDownLatch.countDown();
System.out.println(name + " 工作完成。。。");
}
}
}

创建一个计数器为2的 CountDownLatch ,让Worker持有这个CountDownLatch 实例,当完成自己的工作后,调用countDownLatch.countDown() 方法将计数器减1。countDownLatch.await() 方法会一直阻塞直到计数器为0,主线程才会继续往下执行。

运行结果:

worker1 开始工作了。。。
worker1 工作完成。。。
worker2 开始工作了。。。
worker2 工作完成。。。
准备工作就绪...
worker3 开始工作了。。。
worker3 工作完成。。。

从结果上来看,都解决了问题,但是他们的区别在哪里呢?

业务场景:假设worker的工作可以分为两个阶段,work3 只需要等待work1和work2完成他们各自工作的第一个阶段之后就可以开始自己的工作了,而不是场景1中的必须等待work1和work2把他们的工作全部完成之后才能开始。这样join就不可以实现了,应当采用CountDownLatch 来实现。

public class CountDownLatchTest {

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

        // 初始化计数器为5
CountDownLatch countDownLatch = new CountDownLatch(5); // 三个独立的工人线程
worker worker1 = new worker("worker1", (long) (Math.random() * 4000), countDownLatch);
worker worker2 = new worker("worker2", (long) (Math.random() * 4000), countDownLatch);
worker worker3 = new worker("worker3", (long) (Math.random() * 4000), countDownLatch);
worker worker4 = new worker("worker4", (long) (Math.random() * 4000), countDownLatch);
worker worker5 = new worker("worker5", (long) (Math.random() * 4000), countDownLatch);
worker worker6 = new worker("worker6", (long) (Math.random() * 4000), countDownLatch); worker1.start();
worker2.start();
worker3.start();
worker4.start();
worker5.start(); // 当计数器不为0的时候均等待
countDownLatch.await(); System.out.println("准备工作就绪...");
worker6.start();
} public static class worker extends Thread { private String name;
private long time;
private CountDownLatch countDownLatch; worker(String name, long time, CountDownLatch countDownLatch) {
this.name = name;
this.time = time;
this.countDownLatch = countDownLatch;
} public void run() {
try {
System.out.println(name + " 工作开始。。。");
Thread.sleep(time);
System.out.println(name + " 第一阶段工作完成。。。用时:" + time);
// 计数器减一
countDownLatch.countDown();
// 假设第二阶段的工作都需要两秒完成
Thread.sleep(2000);
System.out.println(name + " 第二阶段工作完成。。。用时:" + (time + 2000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

多运行几次发现:线程6等到前面5个线程的第一阶段全部完成,就开始运行了,运行结果:

worker3 工作开始。。。
worker2 工作开始。。。
worker1 工作开始。。。
worker4 工作开始。。。
worker5 工作开始。。。
worker3 第一阶段工作完成。。。用时:1410
worker5 第一阶段工作完成。。。用时:2022
worker2 第一阶段工作完成。。。用时:2273
worker1 第一阶段工作完成。。。用时:2856
worker3 第二阶段工作完成。。。用时:3410
worker4 第一阶段工作完成。。。用时:3430
准备工作就绪...
worker6 工作开始。。。
worker5 第二阶段工作完成。。。用时:4022
worker2 第二阶段工作完成。。。用时:4273
worker1 第二阶段工作完成。。。用时:4856
worker4 第二阶段工作完成。。。用时:5430
worker6 第一阶段工作完成。。。用时:3773
worker6 第二阶段工作完成。。。用时:5773

总结:调用thread.join() 方法必须等thread 执行完毕,当前线程才能继续往下执行,而CountDownLatch通过计数器提供了更灵活的控制,只要检测到计数器为0当前线程就可以往下执行而不用管相应的thread是否执行完毕。

并发编程大师系列之:CountDownLatch和Join的更多相关文章

  1. 并发编程大师系列之:Synchronized的类锁和对象锁

    说到并发编程,感觉跟大多数人一样,谈之色变,说它简单把,其实很有内容,说难吧,用起来也挺容易,最近我硬着头皮,决心要把并发编程好好的搞一遍.以前,面试的时候,面试官问,并发编程会吗?嗯,接触过,就加一 ...

  2. 并发编程大师系列之:wait/notify/notifyAll/condition

    1. wait().notify()和notifyAll()方法是本地方法,并且为final方法,无法被重写. 2. 调用某个对象的wait()方法能让当前线程阻塞,并且当前线程必须拥有此对象的mon ...

  3. 并发编程大师系列之:线程的定义和中断 interrupt

    1.启动线程的三种方式: 1.1继承Thread类 public static class UseThread extends Thread { public void run() { System. ...

  4. Java并发编程锁系列之ReentrantLock对象总结

    Java并发编程锁系列之ReentrantLock对象总结 在Java并发编程中,根据不同维度来区分锁的话,锁可以分为十五种.ReentranckLock就是其中的多个分类. 本文主要内容:重入锁理解 ...

  5. 并发编程JUC系列AQS(CountDownLatch、CyclicBarrier、Semaphore)

    一.CountDownLatch package com.jonychen.test; import java.util.concurrent.CountDownLatch; import java. ...

  6. JAVA并发编程之倒计数器CountDownLatch

    CountDownLatch 的使用场景:在主线程中开启多线程去并行执行任务,并且主线程需要等待所有子线程执行完毕后汇总返回结果. 我把源码中的英文注释全部删除,写上自己的注释.就剩下 70 行不到的 ...

  7. 并发编程(二)—— CountDownLatch、CyclicBarrier和Semaphore

    本文将讲解CountDownLatch,CyclicBarrier和Semaphore这三个并发包里面的辅助类. CountDownLatch 正如每个Java文档所描述的那样,CountDownLa ...

  8. 并发编程---互斥锁---互斥锁与join的区别

    互斥锁 互斥锁:就是把多个进程并发,修改成一块共享数据的操作变成串行,保证是一个一个来修改的. 缺点:效率低,加锁过程复杂 优点:增加了安全性 from multiprocessing import ...

  9. 并发编程-concurrent指南-计数器CountDownLatch

    java.util.concurrent.CountDownLatch 是一个并发构造,它允许一个或多个线程等待一系列指定操作的完成. CountDownLatch 以一个给定的数量初始化.count ...

随机推荐

  1. python 线程队列LifoQueue-LIFO(36)

    在 python线程队列Queue-FIFO  文章中已经介绍了 先进先出队列Queue,而今天给大家介绍的是第二种:线程队列LifoQueue-LIFO,数据先进后出类型,两者有什么区别呢? 一.队 ...

  2. clang, gcc, gdb

    Clang 比 GCC 编译器的优势: 1 编译速度更快 2 编译产出更小 3 出错提示更友好,比如 clang 在编译过程可以直接指出相对简单的出错位置以及它 " 认为 " 正确 ...

  3. 字典的学习2——参考Python编程从入门到实践

    遍历字典 1. 遍历所有键值对 eg1: user_0 = { 'username': 'efermi', 'first': 'enrico', 'last': 'fermi',}for key, v ...

  4. CSS的三种基本框架

    CSS的三类选择器 1.css-css的基本选择器(三种) 要对哪个标签里面的数据进行操作 (1)标签选择器 div { background-color:red; color:blue; } (2) ...

  5. 20191106-基于Python的对字母基数排序

    基数排序 概念 基数排序的算法过程是先将待排元素补位,使其长度一致,然后按照序列中的元素的每个位数进行分桶的一种算法. 比如待排序列是数字,则将所有待比较数值(正整数)统一为同样的数位长度,数位较短的 ...

  6. Python开发【第二章】:模块和运算符

    一.模块初识: Python有大量的模块,从而使得开发Python程序非常简洁.类库有包括三中: Python内部提供的模块 业内开源的模块 程序员自己开发的模块 1.Python内部提供一个 sys ...

  7. java之aop使用及自定义注解

    目的: 1.Java注解简介 2.Java元注解(重点) 3.自定义注解 案例一(获取类与方法上的注解值) 案例二(获取类属性上的注解属性值) 案例三(获取参数修饰注解对应的属性值) 4.Aop自定义 ...

  8. java 线程同步、死锁

    转载地址:速学堂 https://www.sxt.cn/Java_jQuery_in_action/eleven-thread-synchronization.html 什么是线程同步  同步问题的提 ...

  9. Element ui tree 搜索

    搜索框 属性 :filter-node-method="filterNode" 对树节点进行筛选时执行的方法,返回 true 表示这个节点可以显示,返回 false 则表示这个节点 ...

  10. robot framework 接口测试 http协议post请求json格式

    robot framework 接口测试 http协议post请求json格式 讲解一个基础版本.注意区分url地址和uri地址. rf和jmeter在添加服务器地址也就是ip地址的时候,只能url地 ...