gpt4 book ai didi

CountDownLatch:别浪,等人齐再团!

转载 作者:qq735679552 更新时间:2022-09-27 22:32:09 28 4
gpt4 key购买 nike

CFSDN坚持开源创造价值,我们致力于搭建一个资源共享平台,让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章CountDownLatch:别浪,等人齐再团!由作者收集整理,如果你对这篇文章有兴趣,记得点赞哟.

CountDownLatch:别浪,等人齐再团!

一入王者深似海,从此对象是路人.

哈喽观众老爷们你们好,在下战神吕布字奉先,今天给大家来一部吕布的教学视频.

咳咳,不对。大家好,我是磊哥,今天给大家来一篇 CountDownLatch 的文章.

在开始之前,先问大家一个非常专业的技术性问题:打团战最怕_____?

一道非常简单的送分题,如果答不对,那磊哥就要批评你了,哈哈.

可能有人会说:打团战最怕猪队友,但比猪队友更可怕的是打团战人不齐啊兄弟,想想在打团时如果是 5V2 是怎么一幅画面,心痛到不敢想.

等人齐再团 。

磊哥在儿子没有出生之前,也是资深的农药玩家,至于段位吗?别问!问就是青铜。虽然磊哥的段位不是很高,但基本的大局观还是有的,毕竟也是打过几年 Dota 和 LOL 的青铜玩家是吧?哈哈.

农药和其他 Moba 类游戏是一样的,想要取胜,必须要把握好每次团战,而每次团战的关键在于等人齐了再开团,是吧?而这个思想正好和咱们要讲得 CountDownLatch 的思想是一致的,咱们来看看是怎么回事吧.

吾有上将“CountDownLatch” 。

想象一下这样一个场景,当我们需要等待某些线程执行完之后,再执行主线程的代码,要怎么实现?

可能有人会说,简单,用 join() 方法等待线程执行完成之后再执行主线程就行了,实现代码是这样的:

  1. // 创建线程1 
  2. Thread t1 = new Thread(new Runnable() { 
  3.     @Override 
  4.     public void run() { 
  5.         // do something 
  6.     } 
  7. }); 
  8. t1.start(); 
  9.  
  10. // 创建线程2 
  11. Thread t2 = new Thread(new Runnable() { 
  12.     @Override 
  13.     public void run() { 
  14.         // do something 
  15.     } 
  16. }); 
  17. t2.start(); 
  18.  
  19. // 等待线程 1和线程 2 执行完 
  20. t1.join(); 
  21. t2.join(); 

当然,如果使用的是 Thread 来执行任务,那这种写法也是可行的。然而真实的(编码)环境中我们是不会使用 Thread 来执行多任务的,而是会使用线程池来执行多任务,这样可以避免线程重复启动和销毁所带来的性能开销,实现代码如下:

  1. // 创建固定线程数的线程池 
  2. ExecutorService executorService = Executors.newFixedThreadPool(2); 
  3. // 任务一 
  4. executorService.submit(new Runnable() { 
  5.     @Override 
  6.     public void run() { 
  7.         // do something 
  8.     } 
  9. }); 
  10. // 任务二 
  11. executorService.submit(new Runnable() { 
  12.     @Override 
  13.     public void run() { 
  14.         // do something 
  15.     } 
  16. }); 

那么这时候问题来了,线程池是没有 join() 方法的,那要怎么实现等待呢?

这个时候就要派出我方大将“CountDownLatch”啦.

吾有上将潘凤,可斩华雄... 出场数秒,潘凤...“卒”.

等等导演,我觉得剧情应该是这样的... 。

CountDownLatch使用 。

为了实现等待所有线程池执行完之后再执行主线程的逻辑,我决定使用 AQS(AbstractQueuedSynchronizer,抽象同步框架)下的著名类 CountDownLatch 来实现此功能,具体的实现代码如下:

  1. public static void main(String[] args) throws InterruptedException { 
  2.     // 创建 CountDownLatch 
  3.     CountDownLatch countDownLatch = new CountDownLatch(2); 
  4.  
  5.     // 创建固定线程数的线程池 
  6.     ExecutorService executorService = Executors.newFixedThreadPool(2); 
  7.     // 任务一 
  8.     executorService.submit(new Runnable() { 
  9.         @Override 
  10.         public void run() { 
  11.             // do something 
  12.             try { 
  13.                 // 让此任务执行 1.2s 
  14.                 Thread.sleep(1200); 
  15.             } catch (InterruptedException e) { 
  16.                 e.printStackTrace(); 
  17.             } 
  18.             System.out.println("我是任务一"); 
  19.             countDownLatch.countDown(); 
  20.         } 
  21.     }); 
  22.     // 任务二 
  23.     executorService.submit(new Runnable() { 
  24.         @Override 
  25.         public void run() { 
  26.             // do something 
  27.             try { 
  28.                 // 让此任务执行 1.2s 
  29.                 Thread.sleep(1000); 
  30.             } catch (InterruptedException e) { 
  31.                 e.printStackTrace(); 
  32.             } 
  33.             System.out.println("我是任务二"); 
  34.             countDownLatch.countDown(); 
  35.         } 
  36.     }); 
  37.      
  38.     // 等待任务执行完成 
  39.     countDownLatch.await(); 
  40.     System.out.println("程序执行完成~"); 

以上程序执行结果如下:

CountDownLatch:别浪,等人齐再团!

从上述结果可以看出,主线程的执行是等待任务一和任务二都执行完成之后才执行的.

CountDownLatch实现原理 。

CountDownLatch 中 count down 是倒数的意思,latch 则是门闩的含义。整体含义可以理解为倒数的门栓,似乎有点“321,芝麻开门”的感觉,CountDownLatch 的作用也正是如此.

CountDownLatch 在创建的时候需要传入一个整数,在这个整数“倒数”到 0 之前,主线程需要一直挂起等待,直到其他的线程都执行之后,主线才能继续执行.

CountDownLatch执行流程 。

CountDownLatch 的实现是在其内部创建并维护了一个 volatile 类型的整数计数器,当调用 countDown() 方法时,会尝试将整数计数器 -1,当调用 wait() 方法时,当前线程就会判断整数计数器是否为 0,如果为 0,则继续往下执行,如果不为 0,则使当前线程进入等待状态,直到某个线程将计数器设置为 0,才会唤醒在 await() 方法中等待的线程继续执行.

CountDownLatch常用方法 。

  1. // 线程被挂起直到 count 值为 0 才继续执行 
  2. public void await() throws InterruptedException { };    
  3.  
  4. // 和 await() 类似,只不过等待一定的时间后 count 值还没变为 0 的话就会继续执行 
  5. public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };   
  6.  
  7. // 将 count 值减 1 
  8. public void countDown() { }; 

总结 。

使用 CountDownLatch 可以实现等待所有任务执行完成之后再执行主任务的功能,它就好像比赛中要等待所有运动员都完成比赛之后再公布排名一样,当然我们在玩农药的时候也是一样,要等所有人集合完毕之后再开团,这是制胜的关键。而 CountDownLatch 是通过计数器来实现等待功能的,当创建 CountDownLatch 时会设置一个大于 0 的计数器,每次调用 countDown() 方法时计数器的值会 -1,直到计数器值变为 0 时,等待的任务就可以继续执行了.

参考 & 鸣谢 。

www.jianshu.com/p/128476015902 。

原文地址:https://mp.weixin.qq.com/s/72XXWIMJ230bwfu4PUuS-Q 。

最后此篇关于CountDownLatch:别浪,等人齐再团!的文章就讲到这里了,如果你想了解更多关于CountDownLatch:别浪,等人齐再团!的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。

28 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com