并发技术_4_CyclicBarrier

最新推荐文章于 2022-04-12 20:20:16 发布

Simba_cheng

最新推荐文章于 2022-04-12 20:20:16 发布

阅读量293

点赞数

分类专栏： Java_并发技术文章标签： CyclicBarrier 多线程并发并发基础并发方法

本文链接：https://blog.csdn.net/simba_cheng/article/details/77995967

版权

Java_并发技术专栏收录该内容

4 篇文章 0 订阅

订阅专栏

CyclicBarrier

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

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

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

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

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

(来自：并发编程网)

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

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

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

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

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

构造方法：

newCyclicBarrier(parties) ：

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

初步使用

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

public class MyThread extends Thread {

	private CyclicBarrier cbRef;

	public MyThread(CyclicBarrier cbRef) {
			this.cbRef = cbRef;
	}

	@Override
	public 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() {

	@Override
	public 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到了：1496371755291
	Thread-4到了：1496371755334
	Thread-1到了：1496371755516
	Thread-0到了：1496371755558
	Thread-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;
	}

	@Override
	public 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() {

	@Override
	public 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;
	}

	@Override
	public 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());

	}

}

输出结果：
	1
	2
	0
	1

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

我们修改一下...

public class ThreadA extends Thread {

	private CyclicBarrier cbRef;

	public ThreadA(CyclicBarrier cbRef) {
			this.cbRef = cbRef;
	}

	@Override
	public 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() {

	@Override
	public 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到达屏障..
	1
	t2到达屏障..
	2
	t3到达屏障..
	已经满三个了...
	0
	t4到达屏障..
	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;
	}

	@Override
	public void run() {
			service.testA();
	}

}

public class Run {

	public static void main(String[] args) {

	int parties = 4;

	CyclicBarrier cbRef = new CyclicBarrier(parties, new Runnable() {

	@Override
	public 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 屏障是否损坏：false
			at 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 进来了
	屏障是否损坏：false
	java.lang.InterruptedException
			at 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.BrokenBarrierException
			at 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.BrokenBarrierException
			at 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.BrokenBarrierException
			at 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 屏障是否损坏：true
	catch 屏障是否损坏：true
	catch 屏障是否损坏：true
	catch 屏障是否损坏：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() {

	@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();
	}
	}

}

输出结果：
	Thread-0 准备 1496388782286
	Thread-0 执行了cyclicBarrier.await(5,TimeUnit.SECONDS)
	Thread-1 准备 1496388782286
	Thread-1 执行了cyclicBarrier.await()
	彻底结束了 ： 1496388782286

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

方法getNumberWaiting()和getParties()

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

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

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("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;
	}

	@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 ThreadC extends Thread {

	private MyService service;

	public ThreadC(MyService service) {
			this.service = service;
	}

	@Override
	public 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 准备 1496394419277
	B 准备 1496394419277
	C 准备 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() {

	@Override
	public 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;
	}

	@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 ThreadC extends Thread {

	private MyService service;

	public ThreadC(MyService service) {
			super();
			this.service = service;
	}

	@Override
	public 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 准备 1496452234564
	B 准备 1496452234564
	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_8.MyService.testMethod(MyService.java:20)
			at com.concurrent.cyclicbarrier.cyclicbarrier_8.ThreadA.run(ThreadA.java:13)
	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_8.MyService.testMethod(MyService.java:20)
			at com.concurrent.cyclicbarrier.cyclicbarrier_8.ThreadB.run(ThreadB.java:13)
	同时程序终止

捋一下代码：

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

Simba_cheng

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
并发技术_4_CyclicBarrier

CyclicBarrier 类CyclicBarrier不仅有CountDownLatch所具备的的功能，还可以实现屏障等待的功能，也就是阶段性同步；它在使用上的意义在于可以循环的实现线程要一起做任务的目标，而不是像类CountDownLatch一样，仅仅支持一次线程与同步阻塞的特点。(原文写的是什么叼玩意，看的这么拗口) CyclicBarrier的字面意思是可循环使用(
复制链接

扫一扫