CyclicBarrier的工作原理及其实例

最新推荐文章于 2024-09-05 18:41:44 发布
最新推荐文章于 2024-09-05 18:41:44 发布
阅读量8.2k 收藏 21
点赞数 5
分类专栏： 线程 文章标签： CyclicBarrier 多线程 CountDownLatch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carson0408/article/details/79471490
版权

        CyclicBarrier是多线程中一个重要的类，主要用于线程组内部之间的线程的相互等待问题。

 1.CyclicBarrier的工作原理      

        CyclicBarrier大致是可循环利用的屏障，顾名思义，这个名字也将这个类的特点给明确地表示出来了。首先，便是可重复利用，说明该类创建的对象可以复用；其次，屏障则体现了该类的原理：每个线程执行时，都会碰到一个屏障，直到所有线程执行结束，然后屏障便会打开，使所有线程继续往下执行。

        这里介绍CyclicBarrier的两个构造函数：CyclicBarrier(int parties)和CyclicBarrier(int parties, Runnable barrierAction) :前者只需要声明需要拦截的线程数即可，而后者还需要定义一个等待所有线程到达屏障优先执行的Runnable对象。

        实现原理：在CyclicBarrier的内部定义了一个Lock对象，每当一个线程调用await方法时，将拦截的线程数减1，然后判断剩余拦截数是否为初始值parties，如果不是，进入Lock对象的条件队列等待。如果是，执行barrierAction对象的Runnable方法，然后将锁的条件队列中的所有线程放入锁等待队列中，这些线程会依次的获取锁、释放锁。

        举例说明：如果一个寝室四个人约好了去球场打球，由于四个人准备工作不同，所以约好在楼下集合，并且四个人集合好之后一起出发去球场。

package concurrent;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.*;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.*;
public class CyclicBarrierDemo {
	private static final ThreadPoolExecutor threadPool=new ThreadPoolExecutor(4,10,60,TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>());
	//当拦截线程数达到4时，便优先执行barrierAction，然后再执行被拦截的线程。
	private static final CyclicBarrier cb=new CyclicBarrier(4,new Runnable() {
		public void run()
		{
			System.out.println("寝室四兄弟一起出发去球场");
		}
	});
	private static class GoThread extends Thread{
		private final String name;
		public GoThread(String name)
		{
			this.name=name;
		}
		public void run()
		{
			System.out.println(name+"开始从宿舍出发");
			try {
				Thread.sleep(1000);
				cb.await();//拦截线程
				System.out.println(name+"从楼底下出发");
				Thread.sleep(1000);
				System.out.println(name+"到达操场");
				
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
			catch(BrokenBarrierException e)
			{
				e.printStackTrace();
			}
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] str= {"李明","王强","刘凯","赵杰"};
		for(int i=0;i<4;i++)
		{
			threadPool.execute(new GoThread(str[i]));
		}
		try
		{
			Thread.sleep(4000);
			System.out.println("四个人一起到达球场，现在开始打球");
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		

	}

}

运行程序，得到如下结果：

李明开始从宿舍出发
赵杰开始从宿舍出发
王强开始从宿舍出发
刘凯开始从宿舍出发
寝室四兄弟一起出发去球场
赵杰从楼底下出发
李明从楼底下出发
刘凯从楼底下出发
王强从楼底下出发
赵杰到达操场
王强到达操场
李明到达操场
刘凯到达操场
四个人一起到达球场，现在开始打球

        以上便是CyclicBarrier使用实例，通过await(）方法对线程的拦截，拦截数加1，当拦截数为初始的parties，首先执行了barrierAction，然后对拦截的线程队列依次进行获取锁释放锁。接下来，在这个例子上讲解CyclicBarrier对象的复用特性。

package concurrent;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.*;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.*;
public class CyclicBarrierDemo {
	private static final ThreadPoolExecutor threadPool=new ThreadPoolExecutor(4,10,60,TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>());
	//当拦截线程数达到4时，便优先执行barrierAction，然后再执行被拦截的线程。
	private static final CyclicBarrier cb=new CyclicBarrier(4,new Runnable() {
		public void run()
		{
			System.out.println("寝室四兄弟一起出发去球场");
		}
	});
	private static class GoThread extends Thread{
		private final String name;
		public GoThread(String name)
		{
			this.name=name;
		}
		public void run()
		{
			System.out.println(name+"开始从宿舍出发");
			try {
				Thread.sleep(1000);
				cb.await();//拦截线程
				System.out.println(name+"从楼底下出发");
				Thread.sleep(1000);
				System.out.println(name+"到达操场");
				
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
			catch(BrokenBarrierException e)
			{
				e.printStackTrace();
			}
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] str= {"李明","王强","刘凯","赵杰"};
		String[] str1= {"王二","洪光","雷兵","赵三"};
		for(int i=0;i<4;i++)
		{
			threadPool.execute(new GoThread(str[i]));
		}
		try
		{
			Thread.sleep(4000);
			System.out.println("四个人一起到达球场，现在开始打球");
			System.out.println("现在对CyclicBarrier进行复用.....");
			System.out.println("又来了一拨人，看看愿不愿意一起打：");
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		//进行复用：
		for(int i=0;i<4;i++)
		{
			threadPool.execute(new GoThread(str1[i]));
		}
		try
		{
			Thread.sleep(4000);
			System.out.println("四个人一起到达球场，表示愿意一起打球，现在八个人开始打球");
			//System.out.println("现在对CyclicBarrier进行复用");
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		
		

	}

}

运行如下程序，得到：

王强开始从宿舍出发
赵杰开始从宿舍出发
李明开始从宿舍出发
刘凯开始从宿舍出发
寝室四兄弟一起出发去球场
王强从楼底下出发
李明从楼底下出发
刘凯从楼底下出发
赵杰从楼底下出发
王强到达操场
李明到达操场
赵杰到达操场
刘凯到达操场
四个人一起到达球场，现在开始打球
现在对CyclicBarrier进行复用.....
又来了一拨人，看看愿不愿意一起打：
王二开始从宿舍出发
雷兵开始从宿舍出发
洪光开始从宿舍出发
赵三开始从宿舍出发
寝室四兄弟一起出发去球场
洪光从楼底下出发
王二从楼底下出发
雷兵从楼底下出发
赵三从楼底下出发
雷兵到达操场
赵三到达操场
洪光到达操场
王二到达操场
四个人一起到达球场，表示愿意一起打球，现在八个人开始打球

        由上面实例可了解CyclicBarrier的工作原理以及复用的特性。

2.通过CountDownLatch实现CyclicBarrier

        CountDownLatch通过将await()方法和countDown()方法在不同线程组分别调用，从而实现线程组间的线程等待，即一个线程组等待另一个线程组执行结束再执行。而CyclicBarrier类则是通过调用await()方法实现线程组内的线程等待，即达到需要拦截的线程数，被拦截的线程才会依次获取锁，释放锁。那么将CountDownLatch的用法进行转换，即在同一个线程组内调用await()方法和countDown()方法，则可实现CyclicBarrier类的功能。但是注意的是必须先调用countDown(）方法，才能调用await()方法，因为一旦调用await()方法，该线程后面的内容便不再执行，那么count值无法改变。具体代码如下：

package concurrent;

import java.util.Vector;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class CyclicBarrierWithCount {
	private final static CountDownLatch cdl=new CountDownLatch(3);
	private final static ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());//使用线程池
	
	private static class GoThread extends Thread{
		private final String name;
		
		public GoThread(String name)
		{
			this.name=name;
			
		}
		public void run()
		{
			System.out.println(name+"开始从宿舍出发");
			cdl.countDown();
			try
			{
				Thread.sleep(1000);
				cdl.await();//拦截线程
				System.out.println(name+"从楼底下出发");
				Thread.sleep(1000);
				System.out.println(name+"到达操场");
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}

			
			
		}
	}
	

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		
		String[] str= {"李明","王强","刘凯","赵杰"};
		String[] str1= {"王二","洪光","雷兵","赵三"};
		for(int i=0;i<4;i++)
		{
			threadPool.execute(new GoThread(str[i]));
		}
		try
		{
			Thread.sleep(4000);
			System.out.println("四个人一起到达球场，现在开始打球");
			System.out.println("现在对CyclicBarrier进行复用.....");
			System.out.println("又来了一拨人，看看愿不愿意一起打：");
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		for(int i=0;i<4;i++)
		{
			threadPool.execute(new GoThread(str1[i]));
		}
		try
		{
			Thread.sleep(4000);
			System.out.println("四个人一起到达球场，表示愿意一起打球，现在八个人开始打球");
			//System.out.println("现在对CyclicBarrier进行复用");
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}
	}

}

执行上述代码，结果如下：

李明开始从宿舍出发
赵杰开始从宿舍出发
王强开始从宿舍出发
刘凯开始从宿舍出发
王强从楼底下出发
刘凯从楼底下出发
李明从楼底下出发
赵杰从楼底下出发
李明到达操场
赵杰到达操场
王强到达操场
刘凯到达操场
四个人一起到达球场，现在开始打球
现在对CyclicBarrier进行复用.....
又来了一拨人，看看愿不愿意一起打：
王二开始从宿舍出发
洪光开始从宿舍出发
雷兵开始从宿舍出发
赵三开始从宿舍出发
王二从楼底下出发
洪光从楼底下出发
雷兵从楼底下出发
赵三从楼底下出发
洪光到达操场
王二到达操场
雷兵到达操场
赵三到达操场
四个人一起到达球场，表示愿意一起打球，现在八个人开始打球
        由上面可知，CountDownLatch一定情况下可以实现CyclicBarrier类的功能。


3.CountDownLatch和CyclicBarrier的比较

1.CountDownLatch是线程组之间的等待，即一个(或多个)线程等待N个线程完成某件事情之后再执行；而CyclicBarrier则是线程组内的等待，即每个线程相互等待，即N个线程都被拦截之后，然后依次执行。

2.CountDownLatch是减计数方式，而CyclicBarrier是加计数方式。

3.CountDownLatch计数为0无法重置，而CyclicBarrier计数达到初始值，则可以重置。

4.CountDownLatch不可以复用，而CyclicBarrier可以复用。

carson0408
关注
专栏目录
Java中并发神器之鬼斧神功AQS及工作原理
mmc173168的博客
02-14 856
每当一个线程获取到同步状态时，就利用CAS操作让state减1，直到减到0表示非空闲，其他线程就只能加入到同步队列，进行等待。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。独占模式即在某一时刻只允许一个线程获取同步状态，当这个线程还未释放同步状态时，其他线程是无法获取的，需要加入到同步队列中进行等待。释放同步状态时，需要使用CAS进行操作，因为共享模式下，可能会有多个线程能获取到同步状态。
Cyclicbarrier循环屏障实现demo,
weixin_39098944的博客
09-30 265
前言 我们都知道闭锁（CountDownLatch）和信号量（Semaphore）的实现原理及案例，现在看下一个JDK内置同步器——循环屏障（CyclicBarrier）。通过循环屏障可以实现对多线程的并发控制，只有当到达屏障的线程数量达到指定值时屏障才会放行。实际上CyclicBarrier也可以看成是一个倒计数器，倒计数器的最大值即是屏障的大小，每个线程调用await方法都会让倒计数器的值减一，当倒计数器的值为0时则会让所有等待的线程往下执行。 循环屏障主要的应用场景是在某些节点约束N个线程，比如让指定
CyclicBarrier实现多个线程相互等待的案例（实现累加操作）
11-30
CyclicBarrier实现多个线程相互等待的案例（实现累加操作）
CyclicBarrier实例
洛豳枭薰
06-01 670
1、栅栏的作用就是设定一个阈值，当到达的线程数达到阈值的时候，此时就会放开栅栏，之后执行下一轮循环 2、栅栏除了设定阈值，还可以设定打开栅栏后执行的新任务 public CyclicBarrier(int parties, Runnable barrierAction) { if (parties <= 0) throw new IllegalArgumentExcept...
【JAVA高级】并发同步工具CyclicBarrier 的使用介绍
最新发布
qq_39666711的博客
09-05 1237
CyclicBarrier 是 Java 中的另一个同步辅助类，它可以让一组线程互相等待，直到所有线程都达到一个屏障点后再继续执行。与CountDownLatch 不同的是，CyclicBarrier的计数器可以循环使用，当所有线程都到达屏障点后，计数器会重置，可以被复用。所谓 Cyclic 即循环的意思，所谓 Barrier即屏障的意思。所以综合起来，CyclicBarrier 指的就是循环屏障，虽然这个叫法很奇怪，但是却能很好地表达其含义。
CyclicBarrier使用案例
yupengfeiwangcui的专栏
03-20 314
package com.afei; import java.util.ArrayList; import java.util.List; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class CyclicBarrierTest { private CyclicBarrier cyclicBarrier = new Cy...
【并发工具源码系列】CyclicBarrier 源码解析
菜鸡也有大佬梦
10-15 190
CyclicBarrier 它允许一组线程互相等待，直到到达某个公共屏障点，才会进行后续任务 内部是使用重入锁 ReentrantLock 及其 Condition 。 因为只有一个 await 操作，不像 countDownLatch 和 Semaphore 有释放操作，所以没法调用 release，那么就用 conditon 来阻塞，不用 CLH 队列 属性 /** * Generation 是 CyclicBarrier 内部静态类，描述了 CyclicBarrier 的更新换代。在Cyclic
CyclicBarrier 使用&核心原理 图解
架构师尼恩
10-31 2045
疯狂创客圈 经典图书 ： 《Netty Zookeeper Redis 高并发实战》 面试必备 + 面试必备 + 面试必备 【博客园总入口 】 疯狂创客圈 经典图书 ： 《SpringCloud、Nginx高并发核心编程》 大厂必备 + 大厂必备 + 大厂必备 【博客园总入口 】 入大厂+涨工资必备： 高并发【 亿级流量IM实战】 实战系列 【 SpringCloud Nginx秒杀】 实战系列 【博客园总入口 】 并发工具类 系列文章： 1 Cy..
权威解密：CyclicBarrier工作原理与内部机制的深度剖析
[权威解密：CyclicBarrier工作原理与内部机制的深度剖析](https://codepumpkin.com/wp-content/uploads/2017/09/cyclicBarrier.jpg) # 1. CyclicBarrier简介与使用场景 CyclicBarrier是Java并发包中的一个同步辅助...
Java中的CyclicBarrier原理和应用
CyclicBarrier简介 ## 1.1 CyclicBarrier的概念和作用 在Java并发编程中，CyclicBarrier（循环屏障）是一种同步辅助工具，它允许一组线程互相等待，直到所有线程都准备完毕后再同时继续执行。CyclicBarrier主要...
【Java多线程编程陷阱】：CyclicBarrier的错误使用模式及预防措施
[【Java多线程编程陷阱】：CyclicBarrier的错误使用模式及预防措施](https://codepumpkin.com/wp-content/uploads/2017/09/cyclicBarrier.jpg) # 1. Java多线程编程基础回顾 在现代软件开发中，Java多线程编程是一...
CyclicBarrier的工作原理
qq_40172704的博客
06-22 278
CyclicBarrier的工作原理简单介绍工具初始化测试类await方法dowait方法总结 简单介绍 CyclicBarrier是juc下的多线程工具类，翻译过来就是循环栅栏的意思，在使用CyclicBarrier的时候需要制定线程数 CyclicBarrier cyclicBarrier = new CyclicBarrier(3); 在多线程协作的过程中，只有当指定个数的线程都到达了预定位置线程才会往下执行。下面从源码来分析一下它的工作原理 工具初始化 当调用如下代码初始化CyclicBarrie
CyclicBarrier的例子
zhuhaoyu6666的博客
08-16 181
package com.allen.concurrent.no9; import java.util.Random; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class TestCyclicBarrier { public static void main(String[] args) { // CyclicBarri.
CyclicBarrier使用实例
Donald_Draper
03-06 160
CountDownLatch详解：[url]http://donald-draper.iteye.com/blog/2360597[/url] CountDownLatch是一次性的，CyclicBarrier正好可以循环使用。它允许一组线程互相等待，直到到达某个公共屏障点(common barrier point)。所谓屏障点就是一组任务执行完毕的时刻。下面我们来看一个实例： [code="...
CyclicBarrier 的使用案例
crazy的博客
01-30 224
import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.TimeUnit; import java.util.stream.IntStream; import sta..
CyclicBarrier 应用实例
小白鼠丶
11-12 130
public class CylicBarrierDemo { public static void main(String[] args) throws Exception { CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{ out.println("**...
《Java核心技术》读书笔记：CyclicBarrier的使用示例
bruce128的专栏
12-25 2008
考虑这么一个情景：当多个线程运行到某处的时候，需要将所有的线程的计算结果汇总。那如何控制这些线程计算子问题结束后，在汇总的代码处等待其它线程尚未计算完的线程呢？可以考虑使用CountDownLatch和CyclicBarrier。CountDownLatch只能使用一次，CyclicBarrier作为线程集结点 ，却可以循环使用。“cyclic”循环的意思。     当跑的快的线程运行到Cycl
CyclicBarrier 使用案例详解
weixin_42118323的博客
04-11 2588
CyclicBarrier 概念： CyclicBarrier 字面意思是环栅栏，是 JUC 下的一个并发工具，跟 CountDownLatch 很相似，都可以使线程先等待然后再执行，但是它的功能比 CountDownLatch 更加复杂和强大， CountDownLatch 是一个或者多个线程等待另外一批线程执行完毕后，在接着执行，而 CyclicBarrier 是等待一批线程到达某个状态之后再同时开始执行，回环的意思是当所有的线程被释放后，CyclicBarrier 可以被重启，也就是可以重复使用
CyclicBarrier的用法及实例
不要脸的阿智的博客
09-09 486
CyclicBarrier根据官方文档的说明：一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待； 用人的话来说就是：一组线程在并发的执行过程中，设置一个公共点，只有当每个线程都达到这个公共点的时候，所有的线程才会抢占cpu资源继续运行，否则到达公共点的线程都必须得等待； 构...
Java中断线程：interrupt()方法详解及应用实例
【资源摘要信息】: Java中，如何使用`interrupt()`方法来终止线程是一个关键概念，尤其是在处理多线程编程时。`interrupt()`函数的主要作用...理解`interrupt()`的工作原理和适用场景对于编写健壮的并发程序至关重要。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值