并发库应用之九 & 到时计数器CountDownLatch应用

  申明:CountDownLatch好像倒计时计数器,调用CountDownLatch对象的countDown方法就将计数器减1,当到达0时,所有等待者就开始执行。

  java.util.concurrent.CountDownLatch

  一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier ( 请查看我的另外一篇博客:并发库应用之八 & 循环路障CyclicBarrier应用 )

  CountDownLatch 是一个通用同步工具,它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器,或入口:在通过调用 countDown() 的线程打开入口前,所有调用 await 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待,或者使其在某项操作完成 N 次之前一直等待。

  CountDownLatch 的一个有用特性是,它不要求调用 countDown 方法的线程等到计数到达零时才继续,而在所有线程都能通过之前,它只是阻止任何线程继续通过一个 await。

对应构造方法摘要:

  CountDownLatch(int count)           构造一个用给定计数初始化的 CountDownLatch

方法摘要:

  void  await()                      使当前线程在锁存器倒计数至零之前一直等待,除非线程被中断

  boolean  await(long timeout, TimeUnit unit)    使当前线程在锁存器倒计数至零之前一直等待,除非线程被中断或超出了指定的等待时间

  void  countDown()                       递减锁存器的计数,如果计数到达零,则释放所有等待的线程

  long  getCount()                          返回当前计数

  String  toString()                          返回标识此锁存器及其状态的字符串

案例应用:

  可以实现一个人(也可以是多个人)等待其他所有人都来通知他,这犹如一个计划需要多个领导都签字后才能继续向下实施。还可以实现一个人通知多个人的效果。
类似于生活当中的百米赛跑运动,当裁判一声令下,运动员同时开始奔跑。那么我们下面就用它来实现百米赛跑游戏,上代码:

 1 import java.util.concurrent.CountDownLatch;
 2 import java.util.concurrent.ExecutorService;
 3 import java.util.concurrent.Executors;
 4
 5 public class CountdownLatchTest {
 6
 7     public static void main(String[] args) {
 8         ExecutorService service = Executors.newCachedThreadPool();
 9         //裁判发布命令的计数器,计数器为0好似裁判开起跑枪,运动员就开跑
10         final CountDownLatch cdOrder = new CountDownLatch(1);
11         //预定义有3个运动员,运动员跑到终点的计数器,为0裁判宣布结果
12         final CountDownLatch cdAnswer = new CountDownLatch(3);
13         for (int i = 0; i < 3; i++) { //产生3个运动员
14             Runnable runnable = new Runnable() {
15                 public void run() {
16                     try {
17                         System.out.println(String.format("线程【%s】准备接受起跑命令", Thread.currentThread().getName()));
18                         cdOrder.await();
19
20                         System.out.println(String.format("线程【%s】已接受命令--冲刺", Thread.currentThread().getName()));
21                         Thread.sleep((long) (Math.random() * 5000)); //随机在5s内休眠
22
23                         System.out.println(String.format("线程【%s】回应命令结果--达到终点", Thread.currentThread().getName()));
24                         cdAnswer.countDown();
25                     } catch (Exception e) {
26                         e.printStackTrace();
27                     }
28                 }
29             };
30             service.execute(runnable);
31         }
32         //主线程,开始计数器为1正在阻塞,由主线程出发减1动作,之后3个子线程接收到命令开始冲刺
33         try {
34             Thread.sleep((long) (Math.random() * 5000)); //随机在5s内休眠
35
36             System.out.println(String.format("*裁判*线程【%s】准备开始发布命令,冲刺开枪", Thread.currentThread().getName()));
37             cdOrder.countDown();
38
39             System.out.println(String.format("*裁判*线程【%s】已经完成发布命令,等待比赛结果", Thread.currentThread().getName()));
40             cdAnswer.await();
41
42             System.out.println(String.format("*裁判*线程【%s】已经收到所有回应,宣布比赛结束", Thread.currentThread().getName()));
43         } catch (Exception e) {
44             e.printStackTrace();
45         }
46         service.shutdown();
47     }
48 }

运行以上代码打印的效果如下所示:

  

时间: 2024-10-23 17:07:24

并发库应用之九 & 到时计数器CountDownLatch应用的相关文章

Java多线程与并发库高级应用之倒计时计数器

CountDownLatch 类是一个倒计时计数器,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待.用给定的计数初始化 CountDownLatch.由于调用了countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞.之后,会释放所有等待的线程,await 的所有后续调用都将立即返回. CountDownLatch 是一个通用同步工具,它有很多用途.将计数1初始化的 CountDownLatch 用作一个简单的开/关锁存器,或入口:在通过调用 c

Java复习——多线程与并发库

开启一个线程 实现一个线程的方式有两种:继承Thread类.实现Runnable接口.这两种方法都需要重写Run方法,具体的线程逻辑代码写在Run方法中.其实Thread类就实现了Runnable接口,但是并没有什么说法是使用哪种方式存在效率高低的问题,推荐使用实现Runnable接口的方式,因为更加面向对象,而且实现一个接口比继承一个类更灵活.我们可以使用匿名内部类的方式很方便的开启一个线程(使用Tread类的start方法开启一个线程): Thread : new Thread(){ pub

【java并发】线程并发库的使用

1. 线程池的概念 在java5之后,就有了线程池的功能了,在介绍线程池之前,先来简单看一下线程池的概念.假设我开了家咨询公司,那么每天会有很多人过来咨询问题,如果我一个个接待的话,必然有很多人要排队,这样效率就很差,我想解决这个问题,现在我雇几个客服,来了一个咨询的,我就分配一个客服去接待他,再来一个,我再分配个客服去接待--如果第一个客服接待完了,我就让她接待下一个咨询者,这样我雇的这些客服可以循环利用.这些客服就好比不同的线程,那么装这些线程的容器就称为线程池. 2. Executors的

Java多线程与并发库高级应用之公共屏障点CyclicBarrier

一个小队去登山,每位队员登山的速度不同.山上有几个集合点,在每一集合点处,先到达的队员只有等后面的队员全部到达集合点后才能继续向下一个集合点出发. JDK1.5提供的CyclicBarrier模拟了这种情况.每一个线程相当于一个登山队员,CyclicBarrier相当于山上的集合点.只有等所有线程都执行到了CyclicBarrier后才可以继续向下执行. CyclicBarrier允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point).在涉及一组固定大小的线程

Java多线程与并发库高级应用之信号量Semaphore

JDK1.5提供了一个计数信号量Semaphore类.Semaphore 通常用于限制可以访问某些资源(物理或逻辑的)的线程数目,并提供了同步机制. Semaphore提供了两个构造器来创建对象: 1)Semaphore(int permits):创建具有给定的许可数和非公平的公平设置的Semaphore. 2)Semaphore(int permits, boolean fair):创建具有给定的许可数和给定的公平设置的Semaphore.如果此信号量保证在争用时按先进先出的顺序授予许可,则为

Java多线程与并发库高级应用之阻塞队列BlockingQueue

JDK1.5提供了阻塞队列接口BlockingQueue,它是一个有界阻塞队列.BlockingQueue实现是线程安全的,可以安全地与多个生产者和多个使用者一起使用. 使用时用其实现类 ArrayBlockingQueue,它一个由数组支持的有界阻塞队列.此队列按 FIFO(先进先出)原则对元素进行排序.队列的头部 是在队列中存在时间最长的元素.队列的尾部是在队列中存在时间最短的元素.新元素插入到队列的尾部,队列获取操作则是从队列头部开始获得元素. 这是一个典型的"有界缓存区",固定

Java多线程与并发库高级应用之线程数据交换Exchanger

JDK1.5提供了Exchanger用于两个线程的数据交换.两个线程先后到达交换点,先到达的线程会等待后到达的线程,然后两个线程互相交换数据,交换后双方持对方的数据. Exchanger只提供了一个构造器: Exchanger():创建一个新的Exchanger. Exchanger中也只有两个方法: V exchange(V x): 等待另一个线程到达此交换点(除非当前线程被中断),然后将给定的对象传送给该线程,并接收该线程的对象. V exchange(V x, long timeout,

并发库应用之四 &amp; 线程锁Lock应用

Java5的线程并发库中,提供了相应的线程锁接口Lock来帮助我们同步处理.Lock比传统线程模型中的synchronized更加面向对象,锁本身也是一个对象,两个线程执行的代码要实现同步互斥效果,就要使用同一个锁对象.锁要上在要操作的资源类的内部方法中,而不是线程代码中. java.util.concurrent.locks在并发编程中很常用的实用接口.   |----Lock    实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作   |----ReadWrit

Java多线程与并发库高级应用-java5线程并发库

java5 中的线程并发库 主要在java.util.concurrent包中 还有 java.util.concurrent.atomic子包和java.util.concurrent.lock子包