并发技术_4_CyclicBarrier

CyclicBarrier

 

类CyclicBarrier不仅有CountDownLatch所具备的的功能，还可以实现屏障等待的功能，也就是阶段性同步；

它在使用上的意义在于可以循环的实现线程要一起做任务的目标，而不是像类CountDownLatch一样，仅仅支持一次线程与同步阻塞的特点。

(原文写的是什么叼玩意，看的这么拗口)

 

CyclicBarrier的字面意思是可循环使用(Cyclic)的屏障(Barrier).

它的作用是：让一组线程到达一个屏障(也可以叫同步点)时被阻塞，直到最后一个线程到达屏障，屏障才会开门，所有被屏障拦截的线程才会继续干活。

(来自：并发编程网)

 

CyclicBarrier和Semaphoer及CountDownLatch一样，也是一个同步辅助类。

它允许一组线程互相等待，直到到达某个公共屏障点，这些线程必须实时互相等待，这种情况下就可以使用CyclicBarrier来实现。

CyclicBarrier类的公共屏障点可以重用。

 

其实可以发现，CyclicBarrier与CountDownLatch有些类似，但在细节上还有一些差别。

1. CountDownLatch作用：一个线程或者多个线程，等待另外一个线程或者多个线程完成某个事情之后才能继续执行。
2. CyclicBarrier作用：多个线程之间互相等待，任何一个线程完成之前，所有的线程都必须等待，所以对于CyclicBarrier来说，重点是"多个线程之间"，任何一个线程没有完成任务，则所有的线程都必须等待。
3. CountDownLatch采用的是减法操作，CyclicBarrier的是加法操作。

 

 

 

构造方法：

newCyclicBarrier(parties)：

parties参数表示屏障拦截的线程数量，每个线程调用await()方法告诉CyclicBarrier我已经到达屏障，然后当前线程被阻塞

 

 

 

 

初步使用

测试：所有线程都到达同步点之后，再继续运行。

public class MyThread extends Thread {private CyclicBarrier cbRef;public MyThread(CyclicBarrier cbRef) {this.cbRef = cbRef;}@Overridepublic void run() {try {Thread.sleep((int) (Math.random() * 1000));System.out.println(Thread.currentThread().getName() + "到了：" + System.currentTimeMillis());cbRef.await();} catch (Exception e) {e.printStackTrace();}}}public class Run {public static void main(String[] args) {CyclicBarrier cbRef = new CyclicBarrier(5, new Runnable() {@Overridepublic void run() {System.out.println("全都到了");}});MyThread[] tArr = new MyThread[5];for (int i = 0; i < tArr.length; i++) {tArr[i] = new MyThread(cbRef);}for (int i = 0; i < tArr.length; i++) {tArr[i].start();}}}输出结果：Thread-3到了：1496371755291Thread-4到了：1496371755334Thread-1到了：1496371755516Thread-0到了：1496371755558Thread-2到了：1496371755672全都到了

代码：newCyclicBarrier(5, new Runnable(){...})的作用是设置最大为5个的parties同行者，也就是5个线程都执行了cbRef对象的await()方法后，程序才

可以继续往下执行，否则这些线程彼此互相等待，一直呈阻塞状态。

 

 

 

 

第二个Demo

上一个Demo中，线程的个数与parties的数量是一样的，那如果线程数量大于parties数量时能不能分批处理呢？

public class ThreadA extends Thread {private CyclicBarrier cbRef;public ThreadA(CyclicBarrier cbRef) {this.cbRef = cbRef;}@Overridepublic void run() {try {System.out.println(Thread.currentThread().getName() + " begin = " + System.currentTimeMillis() + " 等待凑齐2个继续运行");cbRef.await();System.out.println(Thread.currentThread().getName() + " end = " + System.currentTimeMillis() + " 已经凑齐两个继续运行");} catch (Exception e) {e.printStackTrace();}}}public class Test {public static void main(String[] args) throws Exception {CyclicBarrier cbRef = new CyclicBarrier(2, new Runnable() {@Overridepublic void run() {System.out.println("全来了");}});for (int i = 0; i < 4; i++) {ThreadA t = new ThreadA(cbRef);t.start();Thread.sleep(2000);}}}输出结果：Thread-0 begin = 1496372797167 等待凑齐2个继续运行Thread-1 begin = 1496372799180 等待凑齐2个继续运行全来了Thread-1 end = 1496372799180 已经凑齐两个继续运行Thread-0 end = 1496372799180 已经凑齐两个继续运行Thread-2 begin = 1496372801193 等待凑齐2个继续运行Thread-3 begin = 1496372803206 等待凑齐2个继续运行全来了Thread-3 end = 1496372803206 已经凑齐两个继续运行Thread-2 end = 1496372803206 已经凑齐两个继续运行

从输出结果上看，CyclicBarrier是可以实现分批处理，也就是每出现两个运动员就开始比赛。

 

 

 

 

验证屏障重置性及getNumberWaiting()方法的使用

CyclicBarrier具有屏障重置性。

来个Demo

public class ThreadA extends Thread {private CyclicBarrier cbRef;public ThreadA(CyclicBarrier cbRef) {this.cbRef = cbRef;}@Overridepublic void run() {try {cbRef.await();} catch (Exception e) {e.printStackTrace();}}}public class Test {public static void main(String[] args) throws Exception {CyclicBarrier cbRef = new CyclicBarrier(3);ThreadA t = new ThreadA(cbRef);t.start();Thread.sleep(500);System.out.println(cbRef.getNumberWaiting());ThreadA t2 = new ThreadA(cbRef);t2.start();Thread.sleep(500);System.out.println(cbRef.getNumberWaiting());ThreadA t3 = new ThreadA(cbRef);t3.start();Thread.sleep(500);System.out.println(cbRef.getNumberWaiting());ThreadA t4 = new ThreadA(cbRef);t4.start();Thread.sleep(500);System.out.println(cbRef.getNumberWaiting());}}输出结果：1201

原书中的栗子的输出结果感觉看不出什么鬼东西...

 

我们修改一下...

public class ThreadA extends Thread {private CyclicBarrier cbRef;public ThreadA(CyclicBarrier cbRef) {this.cbRef = cbRef;}@Overridepublic void run() {try {System.out.println(Thread.currentThread().getName() + "到达屏障..");cbRef.await();} catch (Exception e) {e.printStackTrace();}}}public class Test {public static void main(String[] args) throws Exception {CyclicBarrier cbRef = new CyclicBarrier(3, new Runnable() {@Overridepublic void run() {System.out.println("已经满三个了...");}});ThreadA t = new ThreadA(cbRef);t.setName("t");t.start();Thread.sleep(500);System.out.println(cbRef.getNumberWaiting());ThreadA t2 = new ThreadA(cbRef);t2.setName("t2");t2.start();Thread.sleep(500);System.out.println(cbRef.getNumberWaiting());ThreadA t3 = new ThreadA(cbRef);t3.setName("t3");t3.start();Thread.sleep(500);System.out.println(cbRef.getNumberWaiting());ThreadA t4 = new ThreadA(cbRef);t4.setName("t4");t4.start();Thread.sleep(500);System.out.println(cbRef.getNumberWaiting());}}输出结果：t到达屏障..1t2到达屏障..2t3到达屏障..已经满三个了...0t4到达屏障..1

你看啊..

newCyclicBarrier(3, new Runnable() {..}

当阻塞线程达到3个时候，输出runnable中的内容...

同时，我们输出 "当前阻塞着的线程数量"；

可以看到，当阻塞线程达到3个输出内容之后，计数器被清空为0.

 

so，CyclicBarrier具有屏障重置性，也就是parties的值可以重置归0。

 

 

 

 

 

方法isBroKen()的使用

此方法作用：查询此屏障是否处于损坏状态。

首先，我们来模拟出一个异常情况：

public class MyService {private CyclicBarrier cbRef;public MyService(CyclicBarrier cbRef) {this.cbRef = cbRef;}private void beginRun(int count) {try {System.out.println(Thread.currentThread().getName() + "到了，在等待其他人都到了再开始起跑..");if (Thread.currentThread().getName().equals("Thread-2")) {System.out.println("thread-2 进来了");Thread.sleep(5000);Integer.parseInt("a");// 模拟异常// Thread.currentThread().interrupt();//模拟异常System.out.println("catch 屏障是否损坏：" + cbRef.isBroken());}cbRef.await();System.out.println("都到了，开始跑");System.out.println(Thread.currentThread().getName() + " 到达终点，并结束第 " + count + "赛段");} catch (Exception e) {e.printStackTrace();System.out.println("catch 屏障是否损坏：" + cbRef.isBroken());}}public void testA() {for (int i = 0; i < 1; i++) {beginRun(i + 1);}}}public class MyThread extends Thread {private MyService service;public MyThread(MyService service) {this.service = service;}@Overridepublic void run() {service.testA();}}public class Run {public static void main(String[] args) {int parties = 4;CyclicBarrier cbRef = new CyclicBarrier(parties, new Runnable() {@Overridepublic void run() {System.out.println("都到了");}});MyService service = new MyService(cbRef);MyThread[] tArr = new MyThread[4];for (int i = 0; i < tArr.length; i++) {tArr[i] = new MyThread(service);tArr[i].start();}}}输出结果：Thread-0到了，在等待其他人都到了再开始起跑..Thread-3到了，在等待其他人都到了再开始起跑..Thread-2到了，在等待其他人都到了再开始起跑..Thread-1到了，在等待其他人都到了再开始起跑..thread-2 进来了java.lang.NumberFormatException: For input string: "a"catch 屏障是否损坏：falseat java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)at java.lang.Integer.parseInt(Integer.java:492)at java.lang.Integer.parseInt(Integer.java:527)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyService.beginRun(MyService.java:20)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyService.testA(MyService.java:38)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyThread.run(MyThread.java:13)并且程序还在运行着...

从运行结果来看，有一个线程出现异常报错，则其他线程继续等待，并不影响程序运行的主流程。

 

我们修改下代码：

public class MyService {private CyclicBarrier cbRef;public MyService(CyclicBarrier cbRef) {this.cbRef = cbRef;}private void beginRun(int count) {try {System.out.println(Thread.currentThread().getName() + "到了，在等待其他人都到了再开始起跑..");if (Thread.currentThread().getName().equals("Thread-2")) {System.out.println("thread-2 进来了");Thread.sleep(5000);//Integer.parseInt("a");// 模拟异常 Thread.currentThread().interrupt();//模拟异常System.out.println("catch 屏障是否损坏：" + cbRef.isBroken());}cbRef.await();System.out.println("都到了，开始跑");System.out.println(Thread.currentThread().getName() + " 到达终点，并结束第 " + count + "赛段");} catch (Exception e) {e.printStackTrace();System.out.println("catch 屏障是否损坏：" + cbRef.isBroken());}}public void testA() {for (int i = 0; i < 1; i++) {beginRun(i + 1);}}}输出结果：Thread-1到了，在等待其他人都到了再开始起跑..Thread-0到了，在等待其他人都到了再开始起跑..Thread-3到了，在等待其他人都到了再开始起跑..Thread-2到了，在等待其他人都到了再开始起跑..thread-2 进来了屏障是否损坏：falsejava.lang.InterruptedExceptionat java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:204)at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyService.beginRun(MyService.java:26)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyService.testA(MyService.java:38)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyThread.run(MyThread.java:13)java.util.concurrent.BrokenBarrierExceptionat java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:243)at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyService.beginRun(MyService.java:26)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyService.testA(MyService.java:38)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyThread.run(MyThread.java:13)java.util.concurrent.BrokenBarrierExceptionat java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:243)at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyService.beginRun(MyService.java:26)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyService.testA(MyService.java:38)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyThread.run(MyThread.java:13)java.util.concurrent.BrokenBarrierExceptionat java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:243)at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyService.beginRun(MyService.java:26)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyService.testA(MyService.java:38)at com.concurrent.cyclicbarrier.cyclicbarrier_5.MyThread.run(MyThread.java:13)catch 屏障是否损坏：truecatch 屏障是否损坏：truecatch 屏障是否损坏：truecatch 屏障是否损坏：true

从运行结果来看，四个线程全部进入cath语句块，其中Thread-2进入了Interrupted Exception的catch语句块，其他3个线程进入了BrokenBarrierException

 

CyclicBarrier对于线程的中断interrupte处理会使用"全有"或"全无"的破坏模型，意思是：如果有一个线程由于中断或者超时提前离开了屏障点，其他所有在

屏障点等待的线程也会抛出BrokenBarrierException或者InterruptedException异常，并且离开屏障点。

 

 

 

 

 

方法await(long timeout,TimeUnit unit)超时出现异常的测试

该方法的功能是：如果在指定的时间内达到parties的数量，则程序继续往下运行，如果超出设置的时间，则抛出TimeOutException异常。

public class MyService {        public CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {        @Override        public void run() {                System.out.println("彻底结束了 ： " + System.currentTimeMillis());        }        });        public void testMethod() {                try {        System.out.println(Thread.currentThread().getName() + " 准备 " + System.currentTimeMillis());        if (Thread.currentThread().getName().equals("Thread-0")) {                System.out.println("Thread-0 执行了cyclicBarrier.await(5,TimeUnit.SECONDS)");                cyclicBarrier.await(5, TimeUnit.SECONDS);        }        if (Thread.currentThread().getName().equals("Thread-1")) {                System.out.println("Thread-1 执行了cyclicBarrier.await()");                cyclicBarrier.await();        }        } catch (Exception e) {                e.printStackTrace();        }        }}public class ThreadA extends Thread {        private MyService service;        public ThreadA(MyService service) {                this.service = service;        }        @Override        public void run() {                service.testMethod();        }}public class ThreadB extends Thread {        private MyService service;        public ThreadB(MyService service) {                this.service = service;        }        @Override        public void run() {                service.testMethod();        }}public class Run {        public static void main(String[] args) {        MyService service = new MyService();        ThreadA a = new ThreadA(service);        a.start();        ThreadB b = new ThreadB(service);        b.start();        }}输出结果：        Thread-0 准备 1496388531265        Thread-0 执行了cyclicBarrier.await(5,TimeUnit.SECONDS)        Thread-1 准备 1496388531265        Thread-1 执行了cyclicBarrier.await()        java.util.concurrent.BrokenBarrierException                at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:243)                at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)                at com.concurrent.cyclicbarrier.cyclicbarrier_6.MyService.testMethod(MyService.java:28)                at com.concurrent.cyclicbarrier.cyclicbarrier_6.ThreadB.run(ThreadB.java:13)        java.util.concurrent.TimeoutException                at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)                at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:427)                at com.concurrent.cyclicbarrier.cyclicbarrier_6.MyService.testMethod(MyService.java:23)                at com.concurrent.cyclicbarrier.cyclicbarrier_6.ThreadA.run(ThreadA.java:13)        

从执行的结果来看，计数器设置的是3个线程；

但是我们只启动两个线程，所以当5秒时间还不到时，爆出超时异常。

 

让我们修改一下代码:

public class MyService {public CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable() {@Overridepublic void run() {System.out.println("彻底结束了 ： " + System.currentTimeMillis());}});public void testMethod() {try {System.out.println(Thread.currentThread().getName() + " 准备 " + System.currentTimeMillis());if (Thread.currentThread().getName().equals("Thread-0")) {System.out.println("Thread-0 执行了cyclicBarrier.await(5,TimeUnit.SECONDS)");cyclicBarrier.await(5, TimeUnit.SECONDS);}if (Thread.currentThread().getName().equals("Thread-1")) {System.out.println("Thread-1 执行了cyclicBarrier.await()");cyclicBarrier.await();}} catch (Exception e) {e.printStackTrace();}}}输出结果：Thread-0 准备 1496388782286Thread-0 执行了cyclicBarrier.await(5,TimeUnit.SECONDS)Thread-1 准备 1496388782286Thread-1 执行了cyclicBarrier.await()彻底结束了 ： 1496388782286

你看，当我们将屏障计数器数量设置为两个，然后启动两个线程后，屏障等待就不会产生超时。

 

 

 

 

 

方法getNumberWaiting()和getParties()

getNumberWaiting()的作用是查看有几个线程已经到达屏障点。

getParties()的作用是取得parties个数。

public class MyService {public CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {@Overridepublic void run() {System.out.println("彻底结束了，" + System.currentTimeMillis());}});public void testMethod() {try {System.out.println(Thread.currentThread().getName() + " 准备 " + System.currentTimeMillis());if (Thread.currentThread().getName().equals("C")) {Thread.sleep(Integer.MAX_VALUE);}cyclicBarrier.await();System.out.println(Thread.currentThread().getName() + " 开始 " + System.currentTimeMillis());} catch (Exception e) {e.printStackTrace();}}}public class ThreadA extends Thread {private MyService service;public ThreadA(MyService service) {this.service = service;}@Overridepublic void run() {service.testMethod();}}public class ThreadB extends Thread {private MyService service;public ThreadB(MyService service) {this.service = service;}@Overridepublic void run() {service.testMethod();}}public class ThreadC extends Thread {private MyService service;public ThreadC(MyService service) {this.service = service;}@Overridepublic void run() {service.testMethod();}}public class Run {public static void main(String[] args) throws Exception {MyService service = new MyService();ThreadA a = new ThreadA(service);a.setName("A");ThreadB b = new ThreadB(service);b.setName("B");ThreadC c = new ThreadC(service);c.setName("C");a.start();b.start();c.start();Thread.sleep(2000);System.out.println("屏障对象的parties个数为：" + service.cyclicBarrier.getParties());System.out.println("在屏障处等待的线程个数为：" + service.cyclicBarrier.getNumberWaiting());}}输出数据：A 准备 1496394419277B 准备 1496394419277C 准备 1496394419277屏障对象的parties个数为：3在屏障处等待的线程个数为：2

这里为了达到效果，让C线程，一直处理，无法到达await()方法，这样子，屏障点就只有两个线程。

可以将Thread.sleep(Integer.MAX_VALUE);注释掉试试看。

 

 

 

 

 

方法reset()

方法reset()的作用是重置屏障。

 

将屏障重置为其初始状态。

如果所有参与者目前都在屏障处等待，则它们将返回，同时抛出一个 BrokenBarrierException。

注意，在由于其他原因造成损坏之后，实行重置可能会变得很复杂；此时需要使用其他方式重新同步线程，并选择其中一个线程来执行重置。

与为后续使用创建一个新 barrier相比，这种方法可能更好一些。

--------JDK API

 

public class MyService {public CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {@Overridepublic void run() {System.out.println("一切都结束了...");}});public void testMethod() {try {System.out.println(Thread.currentThread().getName() + " 准备 " + System.currentTimeMillis());cyclicBarrier.await();System.out.println(Thread.currentThread().getName() + " 结束 " + System.currentTimeMillis());} catch (Exception e) {e.printStackTrace();}}}public class ThreadA extends Thread {private MyService service;public ThreadA(MyService service) {this.service = service;}@Overridepublic void run() {service.testMethod();}}public class ThreadB extends Thread {private MyService service;public ThreadB(MyService service) {this.service = service;}@Overridepublic void run() {service.testMethod();}}public class ThreadC extends Thread {private MyService service;public ThreadC(MyService service) {super();this.service = service;}@Overridepublic void run() {service.testMethod();}}public class Run {public static void main(String[] args) throws Exception {MyService service = new MyService();ThreadA a = new ThreadA(service);a.setName("A");ThreadB b = new ThreadB(service);b.setName("B");// C未实例化，达到屏障处阻塞的目的a.start();b.start();Thread.sleep(2000);service.cyclicBarrier.reset();}}输出结果：A 准备 1496452234564B 准备 1496452234564java.util.concurrent.BrokenBarrierExceptionat java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:243)at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)at com.concurrent.cyclicbarrier.cyclicbarrier_8.MyService.testMethod(MyService.java:20)at com.concurrent.cyclicbarrier.cyclicbarrier_8.ThreadA.run(ThreadA.java:13)java.util.concurrent.BrokenBarrierExceptionat java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:243)at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)at com.concurrent.cyclicbarrier.cyclicbarrier_8.MyService.testMethod(MyService.java:20)at com.concurrent.cyclicbarrier.cyclicbarrier_8.ThreadB.run(ThreadB.java:13)同时程序终止

捋一下代码：

1. Run.java运行，实例化MyService，初始化屏障，将屏障处的计数器设置为3，如果屏障处阻塞线程达到3个，就执行cyclicBarrier中的内容。
2. 启动A B两个线程，同时分别调用testMethod()方法，并且调用await()方法，这样子，屏障处就有两个线程阻塞着
3. main主线程，继续往下执行，睡两秒...
4. 然后调用cyclicBarrier.reset()方法，reset()方法，将屏障重置为初始状态；
5. 可以看到，重置屏障之后，阻塞在屏障处的两个线程，出现了Broken异常。