标签：有用 imp 部分 队列 package reset void 使用 details
今天继续学习其它的同步工具：CyclicBarrier与CountDownLatch
一、CyclicBarrier
CyclicBarrier是一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。
CyclicBarrier类似于CountDownLatch也是个计数器， 不同的是CyclicBarrier数的是调用了CyclicBarrier.await()进入等待的线程数， 当线程数达到了CyclicBarrier初始时规定的数目时，所有进入等待状态的线程被唤醒并继续。 CyclicBarrier就象它名字的意思一样，可看成是个障碍， 所有的线程必须到齐后才能一起通过这个障碍。 CyclicBarrier初始时还可带一个Runnable的参数，此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。
构造方法摘要：
| 造方法摘要 |
|---|
| CyclicBarrier(int parties) 创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，但它不会在每个 barrier 上执行预定义的操作。 |
| CyclicBarrier(int parties, Runnable barrierAction) 创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行 |
方法摘要
| 返回值 | 方法 |
|---|---|
| int | await() 在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。 |
| int | await(long timeout, TimeUnit unit) 在所有参与者都已经在此屏障上调用 await 方法之前，将一直等待。 |
| int | getNumberWaiting() 返回当前在屏障处等待的参与者数目。 |
| int | getParties() 返回要求启动此 barrier 的参与者数目。 |
| boolean | isBroken() 查询此屏障是否处于损坏状态。 |
| void | reset() 将屏障重置为其初始状态。 |
代码示例 ：
示例一：
import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; public class CyclicBarrierTest { public static void main(String[] args) { ExecutorService service = Executors.newCachedThreadPool(); final CyclicBarrier cb = new CyclicBarrier(3);//创建CyclicBarrier对象并设置3个公共屏障点 for(int i=0;i<3;i++){ Runnable runnable = new Runnable(){ public void run(){ try { Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点1，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候"); cb.await();//到此如果没有达到公共屏障点，则该线程处于等待状态，如果达到公共屏障点则所有处于等待的线程都继续往下运行 Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点2，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候"); cb.await(); Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点3，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候"); cb.await(); } catch (Exception e) { e.printStackTrace(); } } }; service.execute(runnable); } service.shutdown(); } }
输出：
线程pool-1-thread-2即将到达集合地点1，当前已有0个已经到达，正在等候 线程pool-1-thread-1即将到达集合地点1，当前已有1个已经到达，正在等候 线程pool-1-thread-3即将到达集合地点1，当前已有2个已经到达，正在等候 线程pool-1-thread-3即将到达集合地点2，当前已有0个已经到达，正在等候 线程pool-1-thread-1即将到达集合地点2，当前已有1个已经到达，正在等候 线程pool-1-thread-2即将到达集合地点2，当前已有2个已经到达，正在等候 线程pool-1-thread-3即将到达集合地点3，当前已有0个已经到达，正在等候 线程pool-1-thread-2即将到达集合地点3，当前已有1个已经到达，正在等候 线程pool-1-thread-1即将到达集合地点3，当前已有2个已经到达，正在等候
示例二：
如果在构造CyclicBarrier对象的时候传了一个Runnable对象进去，则每次到达公共屏障点的时候都最先执行这个传进去的Runnable，然后再执行处于等待的Runnable。如果把上面的例子改成下面这样：
package com.thread; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; public class CyclicBarrierTest { public static void main(String[] args) { ExecutorService service = Executors.newCachedThreadPool(); //final CyclicBarrier cb = new CyclicBarrier(3);//创建CyclicBarrier对象并设置3个公共屏障点 final CyclicBarrier cb = new CyclicBarrier(3,new Runnable(){ @Override public void run() { System.out.println("********我最先执行***********"); } }); for(int i=0;i<3;i++){ Runnable runnable = new Runnable(){ public void run(){ try { Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点1，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候"); cb.await();//到此如果没有达到公共屏障点，则该线程处于等待状态，如果达到公共屏障点则所有处于等待的线程都继续往下运行 Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点2，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候"); cb.await(); //这里CyclicBarrier对象又可以重用 Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" + Thread.currentThread().getName() + "即将到达集合地点3，当前已有" + cb.getNumberWaiting() + "个已经到达，正在等候"); cb.await(); } catch (Exception e) { e.printStackTrace(); } } }; service.execute(runnable); } service.shutdown(); } }
结果
线程pool-1-thread-1即将到达集合地点1，当前已有0个已经到达，正在等候 线程pool-1-thread-3即将到达集合地点1，当前已有1个已经到达，正在等候 线程pool-1-thread-2即将到达集合地点1，当前已有2个已经到达，正在等候 ********我最先执行*********** 线程pool-1-thread-1即将到达集合地点2，当前已有0个已经到达，正在等候 线程pool-1-thread-3即将到达集合地点2，当前已有1个已经到达，正在等候 线程pool-1-thread-2即将到达集合地点2，当前已有2个已经到达，正在等候 ********我最先执行*********** 线程pool-1-thread-1即将到达集合地点3，当前已有0个已经到达，正在等候 线程pool-1-thread-3即将到达集合地点3，当前已有1个已经到达，正在等候 线程pool-1-thread-2即将到达集合地点3，当前已有2个已经到达，正在等候 ********我最先执行***********
二、CountDownLatch
一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 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() 返回标识此锁存器及其状态的字符串。 |
代码示例
一种典型用法是，将一个问题分成 N 个部分，用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分，然后将所有 Runnable 加入到 Executor 队列。当所有的子部分完成后，协调线程就能够通过 await。（当线程必须用这种方法反复倒计数时，可改为使用 CyclicBarrier。）
示例一：
import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CountdownLatchTest1 { public static void main(String[] args) { ExecutorService service = Executors. newFixedThreadPool(3); final CountDownLatch latch = new CountDownLatch(3); for (int i = 0; i < 3; i++) { Runnable runnable = new Runnable() { @Override public void run() { try { System. out.println("子线程" + Thread.currentThread().getName() + "开始执行"); Thread. sleep((long) (Math. random() * 10000)); System. out.println("子线程" + Thread.currentThread().getName() + "执行完成"); latch.countDown(); // 当前线程调用此方法，则计数减一 } catch (InterruptedException e) { e.printStackTrace(); } } }; service.execute(runnable); } try { System. out.println("主线程" + Thread.currentThread().getName() + "等待子线程执行完成..." ); latch.await(); // 阻塞当前线程，直到计时器的值为0 System. out.println("主线程" + Thread.currentThread().getName() + "开始执行..."); } catch (InterruptedException e) { e.printStackTrace(); } } }
示例二：百米赛跑，4名运动员选手到达场地等待裁判口令，裁判一声口令，选手听到后同时起跑，当所有选手到达终点，裁判进行汇总汇总排名。
import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CountdownLatchTest2 { public static void main(String[] args) { ExecutorService service = Executors. newCachedThreadPool(); final CountDownLatch cdOrder = new CountDownLatch(1); final CountDownLatch cdAnswer = new CountDownLatch(4); for (int i = 0; i < 4; i++) { Runnable runnable = new Runnable() { public void run() { try { System. out.println("选手" + Thread.currentThread().getName() + "正等待裁判发布口令"); cdOrder.await(); System. out.println("选手" + Thread.currentThread().getName() + "已接受裁判口令"); Thread. sleep((long) (Math. random() * 10000)); System. out.println("选手" + Thread.currentThread().getName() + "到达终点"); cdAnswer.countDown(); } catch (Exception e) { e.printStackTrace(); } } }; service.execute(runnable); } try { Thread. sleep((long) (Math. random() * 10000)); System. out.println("裁判" + Thread.currentThread ().getName() + "即将发布口令" ); cdOrder.countDown(); System. out.println("裁判" + Thread.currentThread ().getName() + "已发送口令，正在等待所有选手到达终点" ); cdAnswer.await(); System. out.println("所有选手都到达终点" ); System. out.println("裁判" + Thread.currentThread ().getName() + "汇总成绩排名" ); } catch (Exception e) { e.printStackTrace(); } service.shutdown(); } }
三、CountDownLatch与CyclicBarrier对比
| CountDownLatch | CyclicBarrier |
|---|---|
| 减计数方式 | 加计数方式 |
| 计算为0时释放所有等待的线程 | 计数达到指定值时释放所有等待线程 |
| 计数为0时，无法重置 | 计数达到指定值时，计数置为0重新开始 |
| 调用countDown()方法计数减一，调用await()方法只进行阻塞，对计数没任何影响 | 调用await()方法计数加1，若加1后的值不等于构造方法的值，则线程阻塞 |
| 不可重复利用 | 可重复利用 |
其它学习资料：
CyclicBarrier的用法
CountDownLatch（倒计时计数器）使用说明
CyclicBarrier和CountDownLatch区别
参考：
《Java多线程与并发库高级应用》张孝祥
JAVA多线程提高十:同步工具CyclicBarrier与CountDownLatch
标签：有用 imp 部分 队列 package reset void 使用 details
原文地址：https://www.cnblogs.com/pony1223/p/9303016.html
