试用栅栏 CyclicBarrier,CountDownLatch以及异常BrokenBarrierException

最新推荐文章于 2025-06-24 00:22:25 发布
最新推荐文章于 2025-06-24 00:22:25 发布
阅读量2k 收藏 1
点赞数 2
CC 4.0 BY-SA版权
分类专栏： Java多线程 文章标签： Java并发 CyclicBarrier  BrokenBarrierException CountDownLatch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hzambrella/article/details/80849501
本文通过实例详细解析了CyclicBarrier与CountDownLatch的工作原理及其应用场景。CyclicBarrier用于同步多个线程，直到所有线程到达指定点后才允许继续执行；CountDownLatch则作为计数器，待计数器归零时解除线程阻塞。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

参考：点击打开链接

CyclicBarrier试用及BrokenBarrierException

CyclicBarrier(int parties, Runnable barrierAction)

通俗的说，它就是一个栅栏,所有线程到了栅栏后必须等待，直到凑够了parties个数量的线程，然后这些线程才可以突破栅栏，继续做事情。否则就等着。

（图片来自参考）

例子： 
package threadTest;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class TestCyclicBarrier implements Runnable{
	final static int ThreadNUM=10;//线程数
	final static int parties=ThreadNUM;//栅栏的parties参数。第二个实验改为6.
	
	//突破栅栏时执行的方法。
	static Runnable barrrierAction1=new Runnable(){
		public void run(){
			System.out.println(Thread.currentThread().getName()+"tripped first barrier");
		}
	};
	static Runnable barrrierAction2=new Runnable(){
		public void run(){
			System.out.println(Thread.currentThread().getName()+"tripped second barrier");
		}
	};
	
	static CyclicBarrier barrier1 =new CyclicBarrier(parties,barrrierAction1);
	static CyclicBarrier barrier2=new CyclicBarrier(parties,barrrierAction2);
	
	
	@Override
	public void run() {
		try {
			Random random=new Random();
			
			int time1=1000+random.nextInt(2000);//1000~3000
			Thread.sleep(time1);
			System.out.println(Thread.currentThread().getName()+":first barrie. num of"+barrier1.getNumberWaiting()+" waiting");
			
			barrier1.await();//第一个栅栏
//			barrier1.await(4,TimeUnit.SECONDS);
			
			int time2=1000+random.nextInt(2000);//1000~3000
			Thread.sleep(time2);
			System.out.println(Thread.currentThread().getName()+":second barrie. num of"+barrier2.getNumberWaiting()+" waiting");
			barrier2.await();//第二个栅栏
//			barrier1.await(4,TimeUnit.SECONDS);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			e.printStackTrace();
		}

	}
	
	public static void main(String[] args) {
		for(int i=0;i<ThreadNUM;i++){
			TestCyclicBarrier test=new TestCyclicBarrier();
			Thread t=new Thread(test);
			t.start();
		}
	}
}



打印：
Thread-8:first barrie. num of0 waiting
Thread-6:first barrie. num of1 waiting
Thread-4:first barrie. num of2 waiting
Thread-0:first barrie. num of3 waiting
Thread-7:first barrie. num of4 waiting
Thread-1:first barrie. num of5 waiting
Thread-9:first barrie. num of6 waiting
Thread-5:first barrie. num of7 waiting
Thread-3:first barrie. num of8 waiting
Thread-2:first barrie. num of9 waiting
Thread-2tripped first barrier
Thread-4:second barrie. num of0 waiting
Thread-3:second barrie. num of1 waiting
Thread-0:second barrie. num of2 waiting
Thread-8:second barrie. num of3 waiting
Thread-1:second barrie. num of4 waiting
Thread-2:second barrie. num of5 waiting
Thread-7:second barrie. num of6 waiting
Thread-6:second barrie. num of6 waiting
Thread-9:second barrie. num of8 waiting
Thread-5:second barrie. num of9 waiting
Thread-5tripped second barrier

存在问题：如果把栅栏的 parties改为6个，程序死在那。

我猜测原因是
CyclicBarrier(int parties)如果 parties小于线程数的话，一部分线程会先突破。后面的被阻挡的线程由于可能凑不够突破数而一直阻塞·，程序无法结束。

把栅栏的parties改成6。有6个线程先突破了。有4个线程没办法突破，因为凑不齐突破条件的6个。

然后发现方法：
intawait(long timeout, TimeUnit unit)

可以带时间参数。超时抛出TimeoutException。想增加个检测超时的，不让程序死。

把两个 barrier.await()改成
barrier.await(4,TimeUnit.SECONDS); //4秒不能突破的话抛出Timeout异常

运行。然后抛出异常


BrokenBarrierException
If any thread is interrupted while waiting, then all other waiting threads will throw BrokenBarrierException and the barrier is placed in the broken state.
翻译下：某个等待的线程被中断，其它等待的线程会抛出这个异常

1个因为超时中断，3个线程抛出BrokenBarrierException。原因显而易见。


闭锁CountDownLatch试用

就是个计数锁。
CountDownlatch countDownLatch=new CountDownlatch (count)；
count代表计数器的大小。当其减少到0时，解除阻塞继续执行代码。

如，一个线程A中
countDownLatch.await();//阻塞
doSomething();

其它线程可以按下计数器，让计数器减1。
countDownLatch.countDown();
然后接着做自己的事情。

线程A的闭锁计数器减少到0时，就解除阻塞，继续做事。

await还有种形式：
boolean await(long timeout, TimeUnit unit)
对于它的返回值
Returns:
true  if the count reached zero and  false  if the waiting time elapsed before the count reached zero
翻译一下
超时的话，如果计数器不为0（ 按计数器的线程没达到期望的数量），返回false，解除阻塞。为0的话（ 按计数器的 线程达到了期望的数量），返回true。

关于CountDownLatch与CyclicBarrier的区别，这篇文章表达很生动。
个人总结：一个是栅栏，一个是计数锁。

下面是自己写的一个关于CountDownLatch使用的生动小例子。如有雷同，她抄我的。
例子：StudentNum 个学生考试。交卷交晚了和中途弃考的考生会不及格。 对待交卷交完的同学，收卷老师很耐心，不会暴力地抓卷，而是耐心地等她做完交卷，然后给她不及格。有个学生会受神秘力量影响，神经错乱大闹考场（被中断了）。但是大家精力都很集中，不会受他的影响而中断考试。 
package threadTest;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class TestCountDownLatch {
	final static int StudentNum = 20;// 线程数
	static volatile boolean isInExam = false;// 是否在考试时间内
	static Map<String, Long> timeUse = new ConcurrentHashMap<>();// 记录交卷时间
	static Set<String> lateSet = new CopyOnWriteArraySet<String>();// 交卷交晚了的学生

	public static void main(String[] args) {
		TestCountDownLatch test = new TestCountDownLatch();
		// 耐心的收卷老师。会等所有考生提交了卷子，而不是抓卷。
		CountDownLatch teacher = new CountDownLatch(StudentNum); 
		// 考试开始的信号，不准提前写卷子。
		CountDownLatch startExamSignal = new CountDownLatch(1);
		// 考试结束的信号，没按时间交卷的同学会被阴险的老师记到lateSet。如果都交卷了，考试提前结束。
		CountDownLatch endExamSignal = new CountDownLatch(StudentNum);

		Thread[] threadList = new Thread[StudentNum];
		// 考生进场
		for (int i = 0; i < StudentNum; i++) {
			threadList[i] = new Thread(test.new Student(
					Integer.toString(10000 + i), startExamSignal, endExamSignal,teacher));
			threadList[i].start();
		}

		// 好像有考生今天不太对劲
		Random random = new Random();
		new Thread(test.new UnexpectedEvent(
				threadList[random.nextInt(StudentNum - 1)], startExamSignal))
				.start();
		isInExam = true;
		// 考试开始！
		System.out.println("老师： 考试开始！");
		startExamSignal.countDown();

		// 老师无聊地监考
		try {
			isInExam = endExamSignal.await(2, TimeUnit.SECONDS);// 考试时间2秒
			System.out.println("老师：考试结束了！！不要写了！！");
			//老师收拾好了所有卷子
			teacher.await();
			System.out.println("老师:下面宣布中途弃考和没按时交卷的考生！！直接不及格！！");
			System.out.println(lateSet);
		} catch (InterruptedException e) {
			System.out.println("考试居然中断了！！！");
			e.printStackTrace();
		}
	}

	class Student implements Runnable {
		private String testNum;// 考号
		private CountDownLatch startExamSignal;// 考试开始的信号
		private CountDownLatch endExamSignal;// 考试结束的信号
		private CountDownLatch teacher;// 收卷老师

		public Student(String testNum, CountDownLatch startExamSignal,
				CountDownLatch endExamSignal,CountDownLatch teacher) {
			this.testNum = testNum;
			this.startExamSignal = startExamSignal;
			this.endExamSignal=endExamSignal;
			this.teacher = teacher;
		}

		@Override
		public void run() {
			Random random = new Random();
			int time1 = 1000 + random.nextInt(2000);// 1000~3000
			long startTime=0;
			try {
				startExamSignal.await();// 不准提前答卷。
				startTime=System.currentTimeMillis();
				Thread.sleep(time1);// 写卷子	
//				System.out.println(teacher.getCount());
			} catch (InterruptedException e) {
				System.out.printf(
						"学生%s：电子竞技处于水深火热中！劳资不考了！" + System.lineSeparator(),testNum);
				//监考人员把他记到不合格名单中。
				lateSet.add(testNum);
				
				e.printStackTrace();
			} finally {
				timeUse.put(testNum,System.currentTimeMillis()-startTime);
				//交卷交晚的，记到不合格名单中。
				if (!isInExam) {
					lateSet.add(testNum);
				}
				System.out.printf("考生%s提交了卷子" + System.lineSeparator(), testNum);
				teacher.countDown();// 交卷给收卷老师
				endExamSignal.countDown();
			}
		}
	}

	// 神秘力量挑选一个学生让他神经错乱（中断）
	class UnexpectedEvent implements Runnable {
		private Thread unfortunatelyStudent;
		private CountDownLatch startExamSignal;// 考试开始的信号

		UnexpectedEvent(Thread unfortunatelyStudent,
				CountDownLatch startExamSignal) {
			this.unfortunatelyStudent = unfortunatelyStudent;
			this.startExamSignal = startExamSignal;
		}

		@Override
		public void run() {
			try {
				Random random = new Random();
				long timeStart = 1200 + random.nextInt(400);
				
				startExamSignal.await();
				long time = System.currentTimeMillis();
				while (System.currentTimeMillis() - time < timeStart) {
				}
				//中断一个线程
				unfortunatelyStudent.interrupt();
			} catch (InterruptedException e) {
				System.out.println("就当啥事都没发生过");
				e.printStackTrace();
			}
		}
	}
}


打印：


正确解决java.util.concurrent.BrokenBarrierException异常的有效解决方法
wbajsjhhhhh的博客
05-12 2268
正确解决java.util.concurrent.BrokenBarrierException异常的有效解决方法
基础篇： CyclicBarrier 和 CountDownLatch 概述
本博客纯属个人网络笔记，如对阁下有用，甚喜；否则，关掉即可，不喜勿喷。专心写代码，不做键盘侠！
12-24 717
文章目录背景Java 并发知识思维导图CyclicBarrier 基本用法构造方法实践编码测试类结果分析CountDownLatch 用法概述使用案例编程启示录 背景 电脑桌面上有一张“Java 并发编程知识思维导图”，最近刚好又用到了 CyclicBarrier 类，这是一篇笔者周末总结的 CyclicBarrier 用法的旧文，今天再对此文修正调整后正好作为专栏的一部分。 Java 并发知识思...
Java并发编程：CountDownLatch、CyclicBarrier和Semaphore
刘成
09-18 382
在java 1.5中，提供了一些非常有用的辅助类来帮助我们进行并发编程，比如CountDownLatch，CyclicBarrier和Semaphore，今天我们就来学习一下这三个辅助类的用法。以下是本文目录大纲： 一.CountDownLatch用法 二.CyclicBarrier用法 三.Semaphore用法 若有不正之处请多多谅解，并欢迎批评指正。一.CountDownLa...
CyclicBarrier详解
最新发布
csdn_tom_168的博客
06-24 1125
Java并发包CyclicBarrier核心解析 CyclicBarrier是JUC中实现多线程同步的关键工具，主要特点包括： 循环屏障机制 - 允许线程组在指定屏障点同步，支持重复使用 双重控制 - 通过ReentrantLock和Condition实现线程安全 阶段回调 - 支持屏障触发时执行预定义Runnable任务 典型应用场景： 多阶段计算（如矩阵运算） 并发测试协调 分布式系统节点同步 使用时需注意： 合理设置屏障数避免死锁 处理中断和超时情况 屏障破裂时的异常处理 该组件特别适用于需要分阶段协
大白话说java并发工具类-CountDownLatch，CyclicBarrier
weixin_34125592的博客
05-06 456
1. 倒计时器CountDownLatch 在多线程协作完成业务功能时，有时候需要等待其他多个线程完成任务之后，主线程才能继续往下执行业务功能，在这种的业务场景下，通常可以使用Thread类的join方法，让主线程等待被join的线程执行完之后，主线程才能继续往下执行。当然，使用线程间消息通信机制也可以完成。其实，java并发工具类中为我们提供了类似“倒计时”这样的工具类，可以十分方便的完成所说...
CountDownLatch与CyclicBarrier
weixin_44442186的博客
04-06 1210
CountDownLatch与CyclicBarrier区别 CountDownLatch JUC包下的并发工具类CountDownLatch，CountDownLatch为递减计数器，用于控制一个线 程等待多个线程。维护一个计数器count，表示需要等待的事件数量，countdown方法递减计数 器，表示事件发生，调用await()方法的线程会一直阻塞直到计数器为零，或者等待中的线程中断， 或者等待超时 CyclicBarrier CyclicBarrier，循环栅栏可以让一组线程等待至某个状态之后再全部
Java计数器之CountDownLatch、CyclicBarrier、Semaphore
weixin_34240520的博客
04-02 134
在Java里面有几种可以用于控制线程状态的方法，如CountDownLatch计数器、CyclicBarrier循环栅栏、Sempahore信号量。下面就分别演示下他们的使用方法： CountDownLatch CountDownLatch可以实现多线程之间的计数器，并实现阻塞功能。比如某个任务依赖于其他的两个任务，只有那两个任务执行结束后，它才能执行。 import java.util.co...
【同步工具】CyclicBarrier和CountDownLatch的区别
WaaTong的博客
01-25 1147
一旦所有线程都到达了屏障点，CyclicBarrier 将会释放所有被阻塞的线程，它们将。是 CyclicBarrier 类中的一个方法，用于使当前线程等待直到所有线程都到达屏障点。计数器可以重复使用，一旦计数器归零，会触发一次屏障操作，然后计数器重新初始化。方法被调用后，当前线程会被阻塞，直到所有参与的线程都调用了 await()适用于多个线程相互等待，直到所有线程都到达一个公共的屏障点后再继续执行。每个线程等待其他所有线程都到达屏障点后再继续执行。计数器只能递减，一旦计数器归零，就无法重置。
CyclicBarrier CountDownLatch
02-16
`CyclicBarrier` 和 `CountDownLatch` 都是 Java 并发包 (`java.util.concurrent`) 中用于线程间同步的工具类，它们帮助协调多个线程之间的操作。尽管两者的目的都是为了控制一组线程的行为，但在使用场景上有所不同...
CountDownLatch和CyclicBarrier的区别（简单聊聊）
21届Java攻城狮&Python民兵
01-26 713
需要注意的是，CyclicBarrier的同步位置是循环的，即当一组线程到达指定的位置后，它们会继续等待其他线程到达指定的位置，然后继续执行。因此，使用CyclicBarrier时需要特别注意循环次数的设置，避免死循环。（注意：若执行线程多余CyclicBarrier的容纳线程，则barrier.await()方法等待方法则不会执行，后续的执行完毕代码不会执行）也可以参考这篇博客。
CyclicBarrier和CountDownLatch的用法与区别
m0_55849656的博客
06-06 363
CyclicBarrier和CountDownLatch这两者的用法 区别
CyclicBarrier的克星—BrokenBarrierException
ljheee的博客
06-17 1962
上篇 CyclicBarrier多任务协同的利器 我们借助部门TB的例子，一步步分析了 CyclicBarrier 多线程协调的功能。 CyclicBarrier 功能强大的同时，意味着提供了更多的API，并且在使用过程中，可能有一些注意点。 今天就来聊聊 BrokenBarrierException，从名字就能看出，是“屏障被破坏异常”，屏障被破坏时，CyclicBarrier 的期望功能就不能完成，甚至导致程序异常； BrokenBarrierException 可谓是 Cyclic
countdownlatch和cyclicbarrier
妙法化城
04-27 316
cyclicbarrier关注的是同一时刻并发执行，在同一个起跑线，在全部线程等待就绪了可以有一个操作 countdownlatch关注的是所有线程都执行完毕 一个经典的场景是: 一个任务有12步，然后要求第三步起每一步都要同时执行（每次同时执行条件满足需要输出一个提示），现在假设有4个任务一个任务起一个线程在所有线程结束后打印结束提示然后整个主线程结束。 在上面的场景中利用countdownla...
BrokenBarrierException 异常
小白爱学习的专栏
06-29 833
package test.java.util.concurrent; import java.util.concurrent.BrokenBarrierException; import org.junit.Test; /** * BrokenBarrierException的测试类 * 栅栏异常，在信号量中抛出 * @author zqw * @date 2020-06-29 21:08:29 */ public class BrokenBarrierExceptionTest { .
CountdownLatch和CyclicBarrier
qq_43430343的博客
10-17 257
1.CountdownLatch 用来进行线程同步协作，等待所有线程完成倒计时。 其中构造参数用来初始化等待计数值，await() 用来等待计数归零, countDown( 用来让计数减一 什么时候倒计时减为0，等待的线程就可以运行了 代码： package demo1; import java.util.concurrent.CountDownLatch; public class CountDownLatchTest { /*让主线程等待其他线程结束后在运行*/ public sta
CountDownLatch和CyclicBarrier
keep on moving
12-04 211
一、CountDownLatch 作用：是让多个线程都完成了各自的功能后同时触发事件 构造方法只有一种CountDownLatch(int count) 主要的方法:await(),countDown()以及await(int time,TimeUnit unit)的重载方法 3.1 await()方法的作用是使当前线程阻塞，直到countDownLatch的count参数的值减为0，才会继续执...
CountDownLatch和CyclicBarrie
qq_52988841的博客
08-20 688
什么是闭锁对象闭锁对象（Latch Object）是一种同步工具，用于控制线程的等待和执行顺序。闭锁对象可以让一个或多个线程等待，直到特定的条件满足后才能继续执行。在Java中，CountDownLatch就是一种常见的闭锁对象。它通过一个计数器来实现线程的等待。计数器的初始值设定为一个正整数，表示需要等待的事件数量。当一个线程完成了一个事件时，计数器的值就会减1。当计数器的值变为0时，所有等待的线程都会被释放，继续执行后续的操作。闭锁对象的主要特点是，一旦计数器的值变为0，就不能再重新设置或重用。
countdownlatch与cyclicbarrier
zh的博客
02-25 487
CountDownLatch会阻塞主线程； CyclicBarrier不会阻塞主线程，只会阻塞子线程；
CountDownLatch、CyclicBarrier、Semaphore详解
Lizhj的博客
08-08 800
目录 CountDownLatch 简介 用法 原理及源码分析 CyclicBarrier 简介 用法 原理及源码分析 Semaphore 简介 用法 原理及源码分析 CountDownLatch 简介 CountDownLatch是 JDK 提供的并发流程控制的工具类，它是在 java.util.concurrent 包下，在 JDK1.5 以后加入，用来进行同步协作，等待所有线程完成倒计时。其中构造函数用来初始化等待计数值，await()用来等待计数归零，countDow.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值