资讯专栏INFORMATION COLUMN

java并发编程学习10--同步器--倒计时门栓

stackfing / 1278人阅读

摘要:每个工作线程在结束前将门栓计数器减一,门栓的计数变为就表明工作完成。常用方法递减锁存器的计数,如果计数到达零,则释放所有等待的线程。使当前线程在锁存器倒计数至零之前一直等待,除非线程被中断或超出了指定的等待时间。

【同步器

java.util.concurrent包包含几个能帮助人们管理相互合作的线程集的类。这些机制具有为线程直间的共用集结点模式提供的‘预制功能’。如果有一个相互合作的线程满足这些行为模式之一,那么应该直接使用提供的类库而不是显示的使用锁与条件的集合。

【倒计时门栓

一个倒计时门栓(CountDownlatch)让一个线程集直到计数变为0.倒计时门栓是一次性的,一旦计数为0就不能再重用了。一个有用的特例是计数值为1的门栓。实现一个只能通过一次的门。线程在门外等待直到另一个线程将计数值变为0。举例来讲,假设一个线程集需要一些初始数据来完成工作。工作线程被启动并在,门外等候,另一个线程准备数据,当数据准备好时,调用countDown(),所有的工作线程就可以继续工作了。然后再使用一个门栓检查什么时候工作线程全部运行完成。每个工作线程在结束前将门栓计数器减一,门栓的计数变为0就表明工作完成。

【常用方法

public void countDown():递减锁存器的计数,如果计数到达零,则释放所有等待的线程。如果当前计数大于零,则将计数减少。如果新的计数为零,出于线程调度目的,将重新启用所有的等待线程。如果当前计数等于零,则不发生任何操作。

public boolean await():使当前线程在锁存器倒计数至零之前一直等待,如果当前计数为零,则此方法立刻返回 true 值。

public boolean await(long timeout,TimeUnit unit) throws InterruptedException:使当前线程在锁存器倒计数至零之前一直等待,除非线程被中断或超出了指定的等待时间。如果当前计数为零,则此方法立刻返回 true 值。如果当前计数大于零,则出于线程调度目的,将禁用当前线程,且在发生以下三种情况之一前,该线程将一直处于休眠状态:

由于调用 countDown() 方法,计数到达零;或者其他某个线程中断当前线程;或者已超出指定的等待时间。如果计数到达零,则该方法返回 true 值。

如果当前线程:在进入此方法时已经设置了该线程的中断状态;或者在等待时被中断,则抛出 InterruptedException,并且清除当前线程的已中断状态。

如果超出了指定的等待时间,则返回值为 false。如果该时间小于等于零,则此方法根本不会等待。

【例子

模拟一个应用程序:在正式开始工作前需要初始化数据,初始化数据使用三个线程,正式执行需要五个线程:

初始化线程

</>复制代码

  1. public class InitThread implements Runnable{
  2. private CountDownLatch downLatch;
  3. private String name;
  4. public InitThread(CountDownLatch downLatch, String name){
  5. this.downLatch = downLatch;
  6. this.name = name;
  7. }
  8. public void run() {
  9. this.doWork();
  10. try{
  11. TimeUnit.SECONDS.sleep(new Random().nextInt(10));
  12. }catch(InterruptedException ie){
  13. }
  14. System.out.println(this.name + "初始化数据完成");
  15. //计数器减一
  16. this.downLatch.countDown();
  17. }
  18. private void doWork(){
  19. System.out.println(this.name + "正在初始化数据... ...");
  20. }
  21. }

初始化线程监视器

</>复制代码

  1. /**
  2. * 检测初始化数据监视器,因为需要判断是否初始化线程全部执行完毕,这里用callable返回结果。runnable不能返回值所以无法判断。
  3. */
  4. public class InitMonitor implements Callable{
  5. private ExecutorService executor;
  6. private CountDownLatch initLatch;
  7. private List initThreads;
  8. public InitMonitor(ExecutorService executor){
  9. this.executor = executor;
  10. //初始化线程:3个
  11. initLatch = new CountDownLatch(3);
  12. initThreads = Arrays.asList(new InitThread(initLatch,"InitOne"),
  13. new InitThread(initLatch,"InitTwo"),
  14. new InitThread(initLatch,"InitThree"));
  15. }
  16. public String call() {
  17. System.out.println("=========初始化START==========");
  18. initThreads.stream().forEach(initThread -> executor.submit(initThread));
  19. try {
  20. initLatch.await();
  21. } catch (InterruptedException e) {
  22. }
  23. System.out.println("***********初始化END*************");
  24. return "INIT_SUCCESS";
  25. }
  26. }

工作线程

</>复制代码

  1. public class ExecuteThread implements Runnable{
  2. private CountDownLatch downLatch;
  3. private String name;
  4. public ExecuteThread(CountDownLatch downLatch, String name){
  5. this.downLatch = downLatch;
  6. this.name = name;
  7. }
  8. public void run() {
  9. this.doWork();
  10. try{
  11. TimeUnit.SECONDS.sleep(new Random().nextInt(10));
  12. }catch(InterruptedException ie){
  13. }
  14. System.out.println(this.name + "执行完成");
  15. //计数器减一
  16. this.downLatch.countDown();
  17. }
  18. private void doWork(){
  19. System.out.println(this.name + "正在执行... ...");
  20. }
  21. }

工作线程监视器

</>复制代码

  1. public class ExecuteMonitor implements Callable{
  2. private ExecutorService executor;
  3. private CountDownLatch executeLatch;
  4. private List executeThreads;
  5. public ExecuteMonitor(ExecutorService executor){
  6. this.executor = executor;
  7. //执行线程:5个
  8. executeLatch = new CountDownLatch(5);
  9. executeThreads = Arrays.asList(new ExecuteThread(executeLatch,"ExecuteOne"),
  10. new ExecuteThread(executeLatch,"ExecuteTwo"),
  11. new ExecuteThread(executeLatch,"ExecuteThree"),
  12. new ExecuteThread(executeLatch,"ExecuteFour"),
  13. new ExecuteThread(executeLatch,"ExecuteFive"));
  14. }
  15. public String call() {
  16. System.out.println("========执行START========");
  17. executeThreads.stream().forEach(executeThread -> executor.submit(executeThread));
  18. try {
  19. executeLatch.await();
  20. } catch (InterruptedException e) {
  21. }
  22. System.out.println("*********执行END*********");
  23. return "EXECUTE_SUCCESS";
  24. }
  25. }

应用程序

</>复制代码

  1. public class Application implements Runnable{
  2. private ExecutorService executor;
  3. private InitMonitor initMonitor;
  4. private ExecuteMonitor executeMonitor;
  5. public Application(ExecutorService executor){
  6. this.executor = executor;
  7. initMonitor = new InitMonitor(executor);
  8. executeMonitor = new ExecuteMonitor(executor);
  9. }
  10. @Override
  11. public void run() {
  12. System.out.println("===============应用程序执行开始====================》》》");
  13. FutureTask initTask = new FutureTask(initMonitor);
  14. executor.submit(initTask);
  15. try {
  16. //如果初始化成功开始执行工作线程,在调用get()时,如果没有执行完成会自动阻塞,所以这里不需要使用isDone检测。
  17. if("INIT_SUCCESS".equals(initTask.get())){
  18. FutureTask executeTask = new FutureTask(executeMonitor);
  19. executor.submit(executeTask);
  20. if("EXECUTE_SUCCESS".equals(executeTask.get())){
  21. executor.shutdown();
  22. System.out.println("===============应用程序执行完毕====================");
  23. }
  24. }
  25. } catch (InterruptedException e) {
  26. e.printStackTrace();
  27. } catch (ExecutionException e) {
  28. e.printStackTrace();
  29. }
  30. }
  31. }

客户端

客户端一定尽量简介,所有细节全部屏蔽,这里只留下一个可以自定义线程池给用户自行选择

</>复制代码

  1. public class Test {
  2. public static void main(String[] args) throws InterruptedException {
  3. ExecutorService executor = Executors.newFixedThreadPool(10);
  4. Application application = new Application(executor);
  5. application.run();
  6. }
  7. }

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/68090.html

相关文章

  • java并发编程学习11--同步--栅栏

    摘要:考虑大量线程运行在一次计算的不同部分的情形。一旦所有的线程都到达了这个栅栏,栅栏就撤销,线程可以继续运行。那些已经在等待的线程立即中止的调用。如果在执行屏障操作过程中发生异常,则该异常将传播到当前线程中,并将置于损坏状态。 【同步器 java.util.concurrent包包含几个能帮助人们管理相互合作的线程集的类。这些机制具有为线程直间的共用集结点模式提供的‘预制功能’。如果有一个...

    desdik 评论0 收藏0
  • BATJ都爱问的多线程面试题

    摘要:今天给大家总结一下,面试中出镜率很高的几个多线程面试题,希望对大家学习和面试都能有所帮助。指令重排在单线程环境下不会出先问题,但是在多线程环境下会导致一个线程获得还没有初始化的实例。使用可以禁止的指令重排,保证在多线程环境下也能正常运行。 下面最近发的一些并发编程的文章汇总,通过阅读这些文章大家再看大厂面试中的并发编程问题就没有那么头疼了。今天给大家总结一下,面试中出镜率很高的几个多线...

    高胜山 评论0 收藏0
  • java并发编程学习9-同步--信号量

    摘要:为了通过信号量,线程通过调用请求许可。许可的数目是固定的,由此限制了线程通过的数量。当设置为时默认也是,此类不对线程获取许可的顺序做任何保证。 【同步器 java.util.concurrent包包含几个能帮助人们管理相互合作的线程集的类。这些机制具有为线程直间的共用集结点模式提供的‘预制功能’。如果有一个相互合作的线程满足这些行为模式之一,那么应该直接使用提供的类库而不是显示的使用锁...

    Jokcy 评论0 收藏0
  • 并发

    摘要:表示的是两个,当其中任意一个计算完并发编程之是线程安全并且高效的,在并发编程中经常可见它的使用,在开始分析它的高并发实现机制前,先讲讲废话,看看它是如何被引入的。电商秒杀和抢购,是两个比较典型的互联网高并发场景。 干货:深度剖析分布式搜索引擎设计 分布式,高可用,和机器学习一样,最近几年被提及得最多的名词,听名字多牛逼,来,我们一步一步来击破前两个名词,今天我们首先来说说分布式。 探究...

    supernavy 评论0 收藏0
  • 并发

    摘要:表示的是两个,当其中任意一个计算完并发编程之是线程安全并且高效的,在并发编程中经常可见它的使用,在开始分析它的高并发实现机制前,先讲讲废话,看看它是如何被引入的。电商秒杀和抢购,是两个比较典型的互联网高并发场景。 干货:深度剖析分布式搜索引擎设计 分布式,高可用,和机器学习一样,最近几年被提及得最多的名词,听名字多牛逼,来,我们一步一步来击破前两个名词,今天我们首先来说说分布式。 探究...

    ddongjian0000 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<