使用CyclicBarrier时,一般都是如下用法,多个线程,然后各线程中调用CyclicBarrier的await()方法,示例如下:
public class CyclicBarrierTest {
private static int SIZE = 3;
private static CyclicBarrier cb;
public static void main(String[] args) {
cb = new CyclicBarrier(SIZE);
for (int i = 0; i < SIZE; i++) {
new MyTask().start();
}
}
static class MyTask extends Thread {
@Override
public void run() {
try {
System.out.println("线程" + Thread.currentThread().getName() + "正在执行同一个任务");
// 以睡眠来模拟几个线程执行一个任务的时间
Thread.sleep(1000);
System.out.println("线程" + Thread.currentThread().getName() + "执行任务完成,等待其他线程执行完毕");
// 用来挂起当前线程,直至所有线程都到达barrier状态再同时执行后续任务;
cb.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("所有线程写入完毕");
}
}
}
画图示意如下:
看ReentrantLock 以下源码, CyclicBarrier 类中有变量
private final ReentrantLock lock = new ReentrantLock();
private final Condition trip = lock.newCondition();
可以推测出其实现依赖于ReentrantLock。
public class CyclicBarrier {
private static class Generation {
boolean broken = false;
}
private final ReentrantLock lock = new ReentrantLock();
private final Condition trip = lock.newCondition();
private final int parties;
private final Runnable barrierCommand;
private Generation generation = new Generation();
private int count;
……省略其他
}
下面进行详细分析,再看CyclicBarrier的await方法:
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();
}
int index = --count;
//如果index=0,则意味着“所有线程到达barrier”
if (index == 0) { // tripped
boolean ranAction = false;
try {
final Runnable command = barrierCommand;
if (command != null)
command.run();
ranAction = true;
nextGeneration();
return 0;
} finally {
if (!ranAction)
breakBarrier();
}
}
// loop until tripped, broken, interrupted, or timed out
for (;;) {
try {
if (!timed)
//调用重入锁的condition的await方法,释放锁(这里释放锁后,其他线程调用CyclicBarrier的await方法时,才能获取到锁),并进入重入锁的条件队列,等待被唤醒
trip.await();
else if (nanos > 0L)
nanos = trip.awaitNanos(nanos);
} catch (InterruptedException ie) {
if (g == generation && ! g.broken) {
breakBarrier();
throw ie;
} else {
// We're about to finish waiting even if we had not
// been interrupted, so this interrupt is deemed to
// "belong" to subsequent execution.
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()方法源码:
private void breakBarrier() {
generation.broken = true;
count = parties;
//唤醒条件队列中的线程
trip.signalAll();
}
CyclicBarrier.await()方法中,会调用lock.lock()获取锁,假如线程1获取锁成功,那线程2和线程3会进入重入锁的同步队列中,等待获取锁:
线程1执行CyclicBarrier.await()方法,当调用到trip.await()时会释放锁,并进入ReentrantLock的条件队列,然后唤醒同步队列中第一个线程,即线程2获取到锁开始执行:
线程2执行时,当调用到trip.await()时会释放锁,并进入ReentrantLock的条件队列,然后唤醒同步队列中第一个线程,即线程3获取到锁开始执行:
线程3执行时,当调用int index = --count后,会index会变为0,那么if (index == 0)判断语句就成立了 ,并会执行 breakBarrier(),该方法中会调用trip.signalAll();将条件队列中的所有线程,即线程1和线程2移入同步队列,线程3释放锁之后,线程1和线程2依次获取锁执行。