CyclicBarrier

最新推荐文章于 2020-08-05 20:01:40 发布
最新推荐文章于 2020-08-05 20:01:40 发布
阅读量276 收藏
点赞数
分类专栏： java并发 文章标签： CyclicBarrier java线程相互等待 java线程实现吃饭的例子 同步辅助类之CyclicBarrier
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Leexichang/article/details/79462612
版权

    前篇文章介绍的CountDownLatch可以用来倒计数，适用于一个线程等待多个线程的情况。如果要实现多个线程互相等待的效果，此时CyclicBarrier就比较合适了。

 

    与CountDownLatch一样，CyclicBarrier也是JDK1.5位于java.util.concurrent包下的一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点（common barrier point），我们姑且称之为barrier（调用await方法之后该线程就处于barrier了）。又因为该barrier在释放等待线程后可以重用，所以称它为cyclic（循环）的barrier。

 

    CyclicBarrier有两个构造器，CyclicBarrier(int parties)和CyclicBarrier(int parties, Runnable barrierAction)。参数parties是一样的，表示启动barrier前必须调用的await()的线程数；参数barrierAction表示在启动barrier时执行的命令，如果不执行任何操作，则该参数可以为null。

 

    在CyclicBarrier的所有方法中，await是最为重要的，它有两个重载方法分别是无参的await()和带时间参数的await(long timeout, TimeUnit unit)，返回值都是int类型，表示到达barrier状态的当前线程索引。await的作用是在所有参与者线程都已经在此barrier上调用await方法之前将一直等待，或者超出了指定的等待时间。

 

    下面我们通过例子来体会CyclicBarrier的用法

    问题：假设有几个许久不见老同学约了一起去“祥来酒店”吃饭，他们说好各自去酒店，然后人到齐了之后再开始点菜吃饭。

 

    在上面的问题中，如果所有的同学没到齐，先到的只能在指定地点等待后来的，直到所有人所有到齐之后才能一起吃。其中在指定地点等待的人就相当于处于barrier状态，当所有人到齐之后barrier状态就被打破，从而继续执行后续操作。

 

    基于上面的分析，代码如下：


package com.gk.thread.barrier;

import java.util.concurrent.CyclicBarrier;

public class Eat {
	
	public static void main(String[] args) {
		
		final int PARTIES = 3;
		CyclicBarrier classmate = new CyclicBarrier(PARTIES);
		
		Runnable r = new EatRunnable(classmate);
		for (int i=1; i<=PARTIES; i++) {
			String name = " classmate--" + i + " ";
			new Thread(r, name).start();
		}
		
	}

}


package com.gk.thread.barrier;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class EatRunnable implements Runnable {

	private CyclicBarrier cb;
	
	public EatRunnable(CyclicBarrier cb) {
		this.cb = cb;
	}
	
	@Override
	public void run() {

		try {
			
			Thread.sleep((long)(Math.random() * 1000) * 60);	// 模拟同学先后达到指定地点
			
			System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + 
								Thread.currentThread().getName() + 
								"已经到达“祥来酒店”......");
			System.out.println();
			
			cb.await();		// 等待其他同学
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		} catch (BrokenBarrierException e) {
			throw new RuntimeException(e);
		}
		
		System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + 
				" 所有人都已经到达“祥来酒店”，可以开始点菜啦...");
		System.out.println();

	}

}


    仔细看运行结果的时间，先到的人等待，当最后一个人到达酒店的时候再全部一起“点菜吃饭”。

 

    好了，吃完饭最尴尬的问题就是谁买单了。为了惩罚最后一个到达的，于是他们就规定由最后一个到达的请客买单。哈哈哈...

 

    这时候CyclicBarrier的另一个构造器CyclicBarrier(int parties, Runnable barrierAction)就派上用场了，它可以在启动barrier时执行给定的屏障操作，并且该操作是由最后一个进入barrier的线程执行的。


package com.gk.thread.barrier;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Pay {

	public static void main(String[] args) {
		
		final int PARTIES = 3;
		CyclicBarrier classmate = new CyclicBarrier(PARTIES, new Runnable() {
			
			@Override
			public void run() {
				System.out.println("由于" + Thread.currentThread().getName() + "是最后一个到达的，所以由TA请客买单...");
				
			}
		});
		
		for (int i=1; i<=PARTIES; i++) {
			String name = " classmate--" + i + " ";
			new Thread(name) {
				
				@Override
				public void run() {

				/*	int number;*/
					try {
						
						Thread.sleep((long)(Math.random() * 1000) * 60);	// 模拟同学先后达到指定地点
						
						System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + 
											Thread.currentThread().getName() + 
											"已经到达指定地点...");
						System.out.println();
						
						/*number = */classmate.await();		// 等待其他同学
					} catch (InterruptedException e) {
						throw new RuntimeException(e);
					} catch (BrokenBarrierException e) {
						throw new RuntimeException(e);
					}
					
					/*if (number == 0)
						System.out.println(Thread.currentThread().getName() + "是最后一个到达的...");*/

				}
			}.start();
		}
	}
}


    其实这种类似的功能也可以用await方法返回值来判断，就像上面注释的代码那样，但显然使用构造器的方式更简洁，也更易于维护。

 

    await(long timeout, TimeUnit unit)与await()的用法是类似的，不同的只是前者可以设置时间。可以参考CountDownLatch，不过与CountDownLatch还有点小小的不同，CyclicBarrier的await(long timeout, TimeUnit unit)方法会抛出TimeoutException异常。


package com.gk.thread.barrier;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class TimeDemo {
	
	public static void main(String[] args){
		
		CyclicBarrier cb = new CyclicBarrier(2);
		
		new Thread() {
			
			@Override
			public void run() {
				
				System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "  " + 
									this.getName() + "开始等待...");

				try {
					cb.await(2L, TimeUnit.SECONDS);	// 等待2秒钟

				} catch (InterruptedException e) {
					throw new RuntimeException(e);
				} catch (BrokenBarrierException e) {
					throw new RuntimeException(e);
				} catch (TimeoutException e) {
					System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "  " +  
									this.getName() + "等待超时，抛出TimeoutException异常...");
				}

			}
			
		}.start();
		
		new Thread() {
			
			@Override
			public void run() {
				
				try {
					
					Thread.sleep(1 * 1000 * 5);	// 设置休眠5秒钟
					cb.await();
					
				} catch (InterruptedException e) {
					throw new RuntimeException(e);
				} catch (BrokenBarrierException e) {
					System.out.println();
					System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "  " + 
										"另一个线程超时啦，抛出BrokenBarrierException异常...");
				}
				
				System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "  " + 
										"CyclicBarrier结束啦...");
			}
			
			
		}.start();
		
	}

}


    此外，CyclicBarrier的另一个重要特性是可以重用。


package com.gk.thread.barrier;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicDemo {
	
	public static void main(String[] args) throws InterruptedException {
		
		final int PARTIES = 3;
		CyclicBarrier cb = new CyclicBarrier(PARTIES);
		
		for (int i=1; i<=PARTIES; i++) {
			new Cyclic(cb).start();
		}
		
		Thread.sleep(1 * 1000 * 10);
		
		System.out.println();
		System.out.println("======++++=====重用CyclicBarrier=====++++======");
		System.out.println();
		
		for (int i=1; i<=PARTIES; i++) {
			new Cyclic(cb).start();
		}
	}
	
	static class Cyclic extends Thread{
		
		CyclicBarrier cb;
		public Cyclic(CyclicBarrier cb) {
			this.cb = cb;
		}

		@Override
		public void run() {
			
			int number;
			
			try {
				
				Thread.sleep((long)(Math.random() * 1000) * 5);
				
				System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "  -->  " + 
						Thread.currentThread().getName());
				System.out.println();
				
				number = cb.await();
				
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
			catch (BrokenBarrierException e) {
				throw new RuntimeException(e);
			}
			
			if (number == 0) {
				System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + 
						" 当前CyclicBarrier结束啦...");
			}
			
		}
		
	}

}


    上面问题的描述只是现实生活中一个形象的比喻。在实际的编程中，比如进行IO操作时，如果要求多个IO操作完之后再进行后续操作的，就可以使用CyclicBarrier来解决了，当然还有很多。









xiaoyao9571
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cyclicbarrier 获取子线程返回值_多种方式处理多线程之间的协调
weixin_39859954的博客
01-27 310
题目：多线程之间需要等待协调，才能完成某种工作，问怎么设计这种协调方案？如：子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次。这个题目主要考查多线程之间的协调，关于线程的协调与通信怎么处理的思路见 多线程之间怎么通讯与协作呢？ 。在并发编程中经常会使用到一些并发工具类，来对线程的并发量、执行流程、资源依赖等进行控制。这里我们主要探讨三...
Java中CyclicBarrier的用法分析
09-05
Java中的`CyclicBarrier`是一个同步辅助类，它允许一组线程互相等待，直到所有线程都到达一个公共的屏障点。这个屏障点就像一个交通信号灯，只有当所有的车辆（线程）都到达了交叉口，信号灯才会变为绿灯，允许它们...
同步屏障CyclicBarrier
tizaitian的专栏
08-05 166
同步屏障CyclicBarrier的字面意思是可循环使用的屏障。它要做的事情是，让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。 默认的构造方法是CycBarrier(int parties)，表示需要达到的线程数。 CyclicBarrier可以被重置。 示例如下： public class CyclicBarrierTest { public static void main(String[] args) throws Int...
JavaDemo——并发工具之CyclicBarrier
FlyLikeButterfly的博客
08-09 246
控制多个线程达到同一条件结束阻塞往下执行，设定值，调用await次数达到设定值，所有await往下执行。容易异常，reset可重置。 Demo： /** * 2019年8月9日上午10:04:26 */ package testThreadUtil.testCyclicBarrier; import java.util.concurrent.BrokenBarrierException...
CyclicBarrier 的用法及使用场景
u012149894的专栏
06-19 1691
CyclicBarrier : 作用：一个同步辅助工具，它允许一组线程全部进行相互等待彼此到达公共的屏障点后，相互等待的线程会进行并发执行后续的代码逻辑 它同时实现了可循环的屏障操作，并且在屏障释放前可以执行额外的一个操作。 应用场景： 非常适合固定大小的线程的程序中使用，这些线程间或彼此等待。 实际项目场景的应用： 数据的采用多线程的组装 使用方式： 1. 创建好 Cyclic...
并发编程-18AQS同步组件之 CyclicBarrier 同步屏障
热门推荐
小工匠
02-24 1万+
文章目录J.U.C脑图CyclicBarrierCyclicBarrier的应用场景示例awaitawait(long timeout, TimeUnit unit)CyclicBarrier(int parties, Runnable barrierAction)CyclicBarrier和CountDownLatch的区别代码 J.U.C脑图 CyclicBarrier CyclicB...
并发编程之屏障CyclicBarrier
梦随风飘的专栏
11-26 1026
它是一个同步辅助类，允许一组线程互相等待，直到到达某个公共屏障点(common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时CyclicBarrier很有用，常用于协调分组的线程的启动和停止。因为该barrier在释放等待线程后可以重用，屏障可以被重复的重置状态。所以称它为循环的barrier。              CyclicBar
Java并发系列之CyclicBarrier源码分析
08-27
Java并发系列之CyclicBarrier源码分析 CyclicBarrier是Java并发系列中的一种同步工具类，用于实现一组线程相互等待。当所有线程都到达某个屏障点后，再进行后续的操作。下面是对CyclicBarrier源码的详细分析。 ...
java线程并发cyclicbarrier类使用示例
09-04
Java中的`CyclicBarrier`是用于多线程同步的一个强大工具，主要应用于一组线程需要在继续执行之前等待其他线程到达某个特定点的情况。它允许开发者定义一个屏障点，只有当所有参与的线程都到达这个屏障点时，它们才...
CyclicBarrier的用法
08-14
在Java多线程编程中，`CyclicBarrier`是一个非常重要的同步工具类，它允许一组线程等待其他线程到达某个屏障点后再一起继续执行。这个屏障点就是我们所说的“循环栅栏”，顾名思义，它就像一个旋转门，所有线程必须...
Java并发实例之CyclicBarrier的使用
08-28
Java并发实例之CyclicBarrier的使用 CyclicBarrier是Java中的一种多线程并发控制实用工具，和CountDownLatch非常类似，它也可以实现线程间的计数等待，但是它的功能比CountDownLatch更加复杂且强大。CyclicBarrier...
Java CyclicBarrier使用
cl2010abc的专栏
07-05 435
概述 CyclicBarrier (周期障碍)类可以帮助同步，它允许一组线程等待整个线程组到达公共屏障点，所有被阻塞的线程才能继续执行。CyclicBarrier好比一扇门，默认情况下关闭状态，堵住了线程执行的道路，直到所有线程都就位，门才打开，让所有线程一起通过。 CyclicBarrier类位于java.util.concurrent包下，CyclicBarrier提供2个构造器： ...
并发之CyclicBarrier的使用
Lyzxii
08-06 915
CyclicBarrier 意思是：环形栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。 示意图如下： 1.CyclicBarrier的构造方法 public CyclicBarrier(in...
CyclicBarrier（同步屏障）的简单使用
分享传递价值
04-12 839
CyclicBarrer简介 CyclicBarrer，可循环使用的屏障，功能是让多个线程到达某个点时被阻塞，直到最后一个线程达到这个屏障便释放所有线程，和CountDownLatch的区别即在于线程释放后屏障是否可重用。 实例化：通过带参数的new CyclicBarrer(N)可实例化CyclicBarrier，N代表需要屏障拦截（阻塞）的线程数，也可以使用new CyclicBarrie...
Condition
xiaoyaoLee1955
02-15 1397
       在上一篇博客《生产者消费者模式之Lock与Condition》中已经对Condition的使用有所了解了，下面再举一个之前在网上看过的例子作为Condition的补充。     问题：假设有三个线程，一个主线程mainThread和两个子线程subThread1、subThread2，要求按顺序输出，mainThread先输出1——3，然后subThread1输出4——6，最后sub...
生产者消费者模式之synchronized与Object
xiaoyaoLee1955
02-15 690
    我在《同步之synchronized关键字》中举了一个春运卖票的例子，在这个例子中实现了使用线程来同时运行多个任务时，通过使用锁（互斥）来同步两个任务的行为，从而使得一个线程不会干涉另一个线程的资源。也就是说，如果两个线程在交替着步入某项共享资源，可以使用互斥来使得任意时刻只有一个线程可以访问这项资源。     虽然这个问题已经得到了解决，但是现实中卖票应该是这样的：首先先产生了票，然后才...
生产者消费者模式之Lock与Condition
xiaoyaoLee1955
02-15 686
        在synchronized中解决线程间通信的生产者消费者问题可以使用Object类的wait()和notify()/notifyAll()方法（可参考），但是我在《同步之Lock锁》中说过Lock是对synchronized的一种更为面向对象的替代，如果我们使用Lock来解决生产者消费者问题又将怎样编写代码呢？在JDK1.5中提供的Condition配套Lock可以实现相同的功能，...
同步之Lock锁
xiaoyaoLee1955
02-15 646
    我在同步之synchronized关键字中说过synchronized真正起作用的是锁对象，不过这个“锁对象”却是隐式监视器锁，我们并不明确是在哪里加上了锁，在哪里释放了锁。为了更明确的表示这种锁的使用，我们可以使用JDK1.5提供的Lock。     在API中是这样介绍Lock的：Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值