本文所使用的源码版本是JDK1.7
CyclicBarrier是什么?
JDK1.7中的介绍如下:
- A synchronization aid that allows a set of threads to all wait for
- each other to reach a common barrier point. CyclicBarriers are
- useful in programs involving a fixed sized party of threads that
- must occasionally wait for each other. The barrier is called
- cyclic because it can be re-used after the waiting threads
- are released.
CyclicBarrier它允许一组线程等待,等待的时间就是执行了await()以后,相当于在await()处建立了一个Barrier,当Barrier被打破(broken),线程才会继续运行await方法后面的程序。而该Barrier在broken后可以重用,所以称它为循环的屏障点。CyclicBarrier支持一个可选的Runnable命令,在一组线程中的最后一个线程到达屏障点之后(Barrier被broken),该命令会被最后一个到达Barrier前的一个线程所执行。
CyclicBarrier的例子
这里我使用了F1赛车的发车的例子。
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
public class F1 {
public static class Car implements Runnable {
private int carId;
private final CyclicBarrier barrier;
public Car(int carId, CyclicBarrier barrier) {
this.barrier = barrier;
this.carId = carId;
}
@Override
public void run() {
try {
System.out.println(carId+"号车准备发车");
TimeUnit.MILLISECONDS.sleep(2000);
barrier.await();//所有的都在這裡阻塞,直到控制信號完成
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(carId+"号车起步了");
}
}
public static class Controll implements Runnable{
@Override
public void run() {
System.out.println("所有车都准备好了,信号灯倒计时");
for(int i=3;i>=0;i--){
try {
TimeUnit.SECONDS.sleep(1);
System.out.println((i==0? "发车":i));
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("执行完控制台的controller的run()以后,唤醒之前阻塞的方法!");
}
}
public static void main(String[] args) throws InterruptedException {
CyclicBarrier barrier = new CyclicBarrier(22, new Controll());
System.out.println("马来西亚大奖赛正赛开始了");
TimeUnit.SECONDS.sleep(3);
for(int i =1;i<23;i++){
new Thread(new Car(i, barrier)).start();;
}
}
}
/*
马来西亚大奖赛正赛开始了
1号车准备发车
2号车准备发车
3号车准备发车
4号车准备发车
......
22号车准备发车
所有车都准备好了,信号灯倒计时
3
2
1
发车
执行完控制台的controller的run()以后,唤醒之前阻塞的方法!
5号车起步了
4号车起步了
2号车起步了
......
22号车起步了
1号车起步了
*/
可以知道,所有的赛车(线程)在执行完await()以后开始在Barrier前面等待,当所有的线程都到达了Barrier前以后,会执行Runnable类的Commond(这里就是信号灯),当Commond执行完run()以后,会打破Barrier,使得等待着的线程继续执行剩下的任务。
CyclicBarrier源码
首先我们先来看一下CyclicBarrier里面有什么
public class CyclicBarrier {
/**内部域broken用来表示当前的屏障是否被打破了*/
private static class Generation {
boolean broken = false;
}
/** lock用于保护屏障入口的锁 */
private final ReentrantLock lock = new ReentrantLock();
/** 用来唤醒阻塞的线程的条件 */
private final Condition trip = lock.newCondition();
/** 线程的数量 */
private final int parties;
/* 所有线程到达Barrier后执行的任务 */
private final Runnable barrierCommand;
/** 当前的栅栏 */
private Generation generation = new Generation();
/**实际中仍在等待的线程数*/
private int count;
}
然后我们来看一下核心方法await()是如何实现的?
public int await() throws InterruptedException, BrokenBarrierException {
try {
return dowait(false, 0L);
} catch (TimeoutException toe) {
throw new Error(toe); // cannot happen;
}
}
private int dowait(boolean timed, long nanos)
throws InterruptedException, BrokenBarrierException,
TimeoutException {
final ReentrantLock lock = this.lock;
lock.lock();
try {
final Generation g = generation;
if (g.broken)
throw new BrokenBarrierException();
if (Thread.interrupted()) {
breakBarrier();
throw new InterruptedException();
}
//count减1,表示还未到达屏障点的线程数量
int index = --count;
//如果所有线程都到了屏障点,那么就由最后一个到达的线程执行Commond
if (index == 0) { // tripped
//表示是否执行了Commond
boolean ranAction = false;
try {
final Runnable command = barrierCommand;
if (command != null)
command.run();
ranAction = true;
//屏障被打破了,那就换一块屏障,用来进行下一次的拦截
nextGeneration();
return 0;
} finally {
//如果没有执行Commond,也就是发生了意外
if (!ranAction)
breakBarrier();
}
}
// 线程一直做for循环,直到发生中断或者超市或者broken
for (;;) {
try {
if (!timed)
trip.await();
else if (nanos > 0L)
nanos = trip.awaitNanos(nanos);
} catch (InterruptedException ie) {
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 {
lock.unlock();
}
}
breakBarrier()和nextGeneration()
//表示顺利执行了Commond,换一下屏障
private void nextGeneration() {
// 让阻塞的线程继续执行下去
trip.signalAll();
// 重置count
count = parties;
//换一块屏障
generation = new Generation();
}
//表示Commond执行出现了意外,修改broken的值,然后继续执行被屏障拦截的线程
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(); // break the current generation
nextGeneration(); // start a new generation
} finally {
lock.unlock();
}
}