Java并发工具类-循环屏障CyclicBarrier
- CyclicBarrier简介
- CyclicBarrier API
- 构造方法
- await方法
- reset方法
- 使用样例
- CyclicBarrier源码详解
- CyclicBarrier中属性
- 构造方法及初始化
- 核心await方法
- 其他方法
- nextGeneration方法
- breakBarrier方法
- reset方法
CyclicBarrier简介
- 一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。
- CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作 很有用。
简单来说,CyclicBarrier就是一个同步屏障,通过await方法使线程处于等待状态,当等待的线程达到一定的数量时(这个就是公共屏障点),所有的线程都会被唤醒,这个数量通过构造方法传入.通过reset方法可以重置屏障
CyclicBarrier API
CyclicBarrier主要方法包括await方法,reset方法,以及两个构造器方法
构造方法
public CyclicBarrier(int parties):
public CyclicBarrier(int parties)
创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，
但它不会在启动 barrier 时执行预定义的操作。
public CyclicBarrier(int parties,Runnable barrierAction):
public CyclicBarrier(int parties,Runnable barrierAction)
创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。
await方法
public int await()
throws InterruptedException,
BrokenBarrierException在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。
如果当前线程不是将到达的最后一个线程，出于调度目的，将禁用它，且在发生以下情况之一前，该线程将一直处于休眠状态：最后一个线程到达；或者
其他某个线程中断当前线程；或者
其他某个线程中断另一个等待线程；或者
其他某个线程在等待 barrier 时超时；或者
其他某个线程在此 barrier 上调用 reset()。
如果当前线程：在进入此方法时已经设置了该线程的中断状态；或者
在等待时被中断
则抛出 InterruptedException，并且清除当前线程的已中断状态。
如果在线程处于等待状态时 barrier 被 reset()，或者在调用 await 时 barrier 被损坏，抑或任意一个线程正处于等待状态，则抛出 BrokenBarrierException 异常。如果任何线程在等待时被 中断，则其他所有等待线程都将抛出 BrokenBarrierException 异常，并将 barrier 置于损坏状态。
如果当前线程是最后一个将要到达的线程，并且构造方法中提供了一个非空的屏障操作，则在允许其他线程继续运行之前，当前线程将运行该操作。如果在执行屏障操作过程中发生异常，则该异常将传播到当前线程中，并将 barrier 置于损坏状态。
返回：
到达的当前线程的索引，其中，索引 getParties() - 1 指示将到达的第一个线程，零指示最后一个到达的线程
抛出：
InterruptedException - 如果当前线程在等待时被中断
BrokenBarrierException - 如果另一个 线程在当前线程等待时被中断或超时，或者重置了 barrier，或者在调用 await 时 barrier 被损坏，抑或由于异常而导致屏障操作（如果存在）失败。
出了上面这个await方法,await还存在一个带超时时间的方法,允许设置一个超时时间public int await(long timeout,TimeUnit unit)的方法,表示在所有线程到达之前或超出指定超时时间之前线程一直等待
reset方法
public void reset()将屏障重置为其初始状态。如果所有参与者目前都在屏障处等待，则它们将返回，同时抛出一个 BrokenBarrierException。注意，在由于其他原因造成损坏之后，实行重置可能会变得很复杂；此时需要使用其他方式重新同步线程，并选择其中一个线程来执行重置。与为后续使用创建一个新 barrier 相比，这种方法可能更好一些。
使用样例
1.使用CyclicBarrier模仿倚天屠龙记中六大门派围攻光明顶
package thread.concurrentutil ;
import java.util.concurrent.CyclicBarrier ;
/**
* 门派线程,用来表示六大门派
*/
class MenPai implements Runnable {
// 名称
private String name ;
// 到达光明顶所需要的时间
private long time ;
// CyclicBarrier
private CyclicBarrier cyclicBarrier ;
public MenPai(String name, long time, CyclicBarrier cyclicBarrier) {
super() ;
this.name = name ;
this.time = time ;
this.cyclicBarrier = cyclicBarrier ;
}
@Override
public void run() {
System.out.println(name + "出发前往光明顶") ;
try {
Thread.sleep(time) ;
System.out.println(name + "到达光明顶") ;
cyclicBarrier.await() ;
} catch (Exception e) {
e.printStackTrace() ;
}
}
}
/**
* CyclicBarrier使用demo
* 通过CyclicBarrier模仿六大门派围攻光明顶
*
*/
public class CyclicBarrierDemo {
public static void main(String [] args) {
// 定义CyclicBarrier,传入6表示需要六大门派到期
CyclicBarrier cyclicBarrier = new CyclicBarrier(6, new Runnable() {
@Override
public void run() {
System.out.println("六大门派到期,开始围攻光明顶") ;
}
}) ;
new Thread(new MenPai("少林", 3000, cyclicBarrier)).start() ;
new Thread(new MenPai("武当", 5000, cyclicBarrier)).start() ;
new Thread(new MenPai("峨眉", 2000, cyclicBarrier)).start() ;
new Thread(new MenPai("昆仑", 6000, cyclicBarrier)).start() ;
new Thread(new MenPai("崆峒", 3000, cyclicBarrier)).start() ;
new Thread(new MenPai("华山", 3500, cyclicBarrier)).start() ;
}
}
运行结果:
少林出发前往光明顶
峨眉出发前往光明顶
昆仑出发前往光明顶
武当出发前往光明顶
华山出发前往光明顶
崆峒出发前往光明顶
峨眉到达光明顶
崆峒到达光明顶
少林到达光明顶
华山到达光明顶
武当到达光明顶
昆仑到达光明顶
六大门派到期,开始围攻光明顶
这个样例演示了,CyclicBarrier作为同步屏障的用法,下面通过CyclicBarrier模仿一个棋牌室的打麻将的场景,展示一下CyclicBarrier作为循环屏障的用法
package thread.concurrentutil;
import java.util.Random ;
import java.util.concurrent.CyclicBarrier ;
/**
* 玩家类,表示打麻将的人
*/
class Player implements Runnable {
// 姓名
private String name;
// 到达麻将馆所需时间
private long time;
// 到达麻将馆所需时间
CyclicBarrier cyclicBarrier;
public Player(String name, long time, CyclicBarrier cyclicBarrier) {
super() ;
this.name = name ;
this.time = time ;
this.cyclicBarrier = cyclicBarrier ;
}
@Override
public void run() {
System.out.println(name + "出发前往麻将馆") ;
try {
// 休眠一段时间,表示路上所需时间
Thread.sleep(time);
// 需要等待集齐四个人
cyclicBarrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* CyclicBarrier使用demo
* 通过CyclicBarrier模仿打麻将的场景,每到期四个人就开一桌麻将
*
*/
public class CyclicBarrierDemo2 {
public static void main(String [] args) throws Exception {
// 定义CyclicBarrier,传入5表示加上当前main线程在内,需要有5个线程处于等待状态时,才会唤醒所有线程
CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
// 人员编号, 桌子编号
int playerIndex = 1, deskIndex = 1;
while(true){
new Thread(new Player("玩家" + playerIndex++, new Random().nextInt(5000), cyclicBarrier)).start();
new Thread(new Player("玩家" + playerIndex++, new Random().nextInt(5000), cyclicBarrier)).start();
new Thread(new Player("玩家" + playerIndex++, new Random().nextInt(5000), cyclicBarrier)).start();
new Thread(new Player("玩家" + playerIndex++, new Random().nextInt(5000), cyclicBarrier)).start();
// 在人员到期之前,让主线程处于等待状态
cyclicBarrier.await();
System.out.println("人员已到齐,第" + (deskIndex++) + "桌开始游戏") ;
}
}
}运行结果:
玩家3出发前往麻将馆
玩家4出发前往麻将馆
玩家2出发前往麻将馆
玩家1出发前往麻将馆
人员已到齐,第1桌开始游戏
玩家5出发前往麻将馆
玩家6出发前往麻将馆
玩家7出发前往麻将馆
玩家8出发前往麻将馆
人员已到齐,第2桌开始游戏
CyclicBarrier源码详解
CyclicBarrier中属性
/** 一个可重入锁,用于保证同一时间只有一个线程能进入await方法 */
private final ReentrantLock lock = new ReentrantLock();
/** Condition简单解释:
* Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，
* 以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。
* 其中，Lock 替代了 synchronized 方法和语句的使用，
* Condition 替代了 Object 监视器方法的使用。
*/
/** 通过使用Condition的await()方法,保证在所有线程到达屏障点之前,其他线程处于等待状态 */
private final Condition trip = lock.newCondition();
/** 屏障点,简单来说当处于wait状态的数量达到这个值时,所有线程都会被唤醒 */
private final int parties;
/* 所有线程到达屏障点之后,执行的线程,这个是一个可选参数 */
private final Runnable barrierCommand;
/** 当前的屏障点实例,generation是CyclicBarrier的一个静态内部类 */
private Generation generation = new Generation();
/**
* 当前还在等待的线程数量,从parties开始递减,当达到0时,所有线程被唤醒
*/
private int count;Generation源码:
private static class Generation {
// 表示线程是否被中断过
boolean broken = false;
}构造方法及初始化
/**
* parties:传入屏障点数量,当等待的线程达到这个数量时,唤醒所有线程
*/
public CyclicBarrier(int parties) {
this(parties, null);
}
/**
* parties:传入屏障点数量,当等待的线程达到这个数量时,唤醒所有线程
* barrierAction : 传入一个Runnable的实例,当所有线程到达屏障点时,执行barrierAction的run方法
*/
public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
this.count = parties;
this.barrierCommand = barrierAction;
}核心await方法
await方法有两个,一个无参的,一个有参的方法,两个方法都是通过调用内部的dowait方法实现的.
public int await() throws InterruptedException, BrokenBarrierException {
try {
return dowait(false, 0L);
} catch (TimeoutException toe) {
throw new Error(toe); // cannot happen
}
}
public int await(long timeout, TimeUnit unit)
throws InterruptedException,
BrokenBarrierException,
TimeoutException {
return dowait(true, unit.toNanos(timeout));
}dowait方法详解:
/**
* 主要的屏障代码,各种情况都在这里进行处理.
*/
private int dowait(boolean timed, long nanos)
throws InterruptedException, BrokenBarrierException,
TimeoutException {
// 获取当前屏障的可重入锁
final ReentrantLock lock = this.lock;
// 获取锁,保证下面的代码同一时间只有一个线程能执行,保证CyclicBarrier的各个属性的线程全性
lock.lock();
try {
// 获取当前屏障
final Generation g = generation;
// broken表示当前线程是否被打断过,如果被打断过,就抛出BrokenBarrierException异常
if (g.broken)
throw new BrokenBarrierException();
// 判断当前线程是否被打断了
if (Thread.interrupted()) {
// 如果当前线程被打断了,就将当前屏障状态g.broken设置为true
// 重置count并唤醒所有等待中的线程
breakBarrier();
throw new InterruptedException();
}
// 每个线程调用await方法时,都将count减1
int index = --count;
// 表示count减为0了,表示所有线程都已到达屏障点,可以唤醒所有线程了
if (index == 0) { // tripped
// 标识是否已经执行了barrierCommand中的操作
boolean ranAction = false;
try {
// 获取当前的CyclicBarrier的,barrierCommand
final Runnable command = barrierCommand;
// 判断有没有传入额外的Runnable实例,如果传入了,就调用Runnable的run方法
if (command != null)
command.run();
// barrierCommand为空或run方法已经执行之后,就将ranAction方法设置为空
ranAction = true;
// 重置屏障点,这里实现CyclicBarrier的循环屏障,nextGeneration方法会唤醒所有处于等待状态的线程
nextGeneration();
return 0;
} finally {
// 如果最终ranAction为false,表示有线程被打断了,调用breakBarrier方法中断当前屏障
if (!ranAction)
breakBarrier();
}
}
// 死循环,在所有线程到达屏障点之前,让线程都处于等待状态
for (;;) {
try {
// 判断是否设置了超时时间
if (!timed)
// 如果没有设置超时时间,就直接使用Condition的await方法让当前线程处于等待状态
// await是个非阻塞方法
trip.await();
else if (nanos > 0L)
// 如果设置了超时时间,则调用Condition的超时等待方法
nanos = trip.awaitNanos(nanos);
} catch (InterruptedException ie) {
// 如果期间线程被打断了,且屏障broken状态不是被打断状态,就更改为打断状态,并唤醒所有等待线程
if (g == generation && ! g.broken) {
breakBarrier();
throw ie;
} else {
// 打断线程
Thread.currentThread().interrupt();
}
}
if (g.broken)
throw new BrokenBarrierException();
if (g != generation)
return index;
// 如果等待时间超时,则抛出超时异常
if (timed && nanos <= 0L) {
breakBarrier();
throw new TimeoutException();
}
}
} finally {
// dowait方法执行完毕,释放可重入锁
lock.unlock();
}
}其他方法
nextGeneration方法
/**
* 唤醒所有等待中的线程,开启下一个屏障
* 开启下一个屏障
*/
private void nextGeneration() {
// Condition的signalAll方法,唤醒所有在当前condition上等待的线程
trip.signalAll();
// 重置count计数为屏障初始值
count = parties;
// 开启下一个新的屏障
generation = new Generation();
}breakBarrier方法
/**
* 中断当前屏障
*/
private void breakBarrier() {
// 将当前屏障状态broken状态设置为true,表示当前屏障被中断了
generation.broken = true;
// 重置count计数
count = parties;
// 唤醒所有等待中的线程
trip.signalAll();
}reset方法
public void reset() {
// 获取当前屏障锁的引用
final ReentrantLock lock = this.lock;
// 获取锁
lock.lock();
try {
// 中断当前屏障
breakBarrier();
// 开启一个新的屏障
nextGeneration();
} finally {
lock.unlock();
}
}