CyclicBarrier的介绍和源码分析 CyclicBarrier的字母意思是可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫做同步点）时被阻塞，直到最后一个线程到达屏障，屏障才会开门，所有被屏障拦截的线程才会继续干活。
线程进入屏障通过CyclicBarrier的await()方法。 CyclicBarrier默认的构造方法是CyclicBarrier(int parties)。其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达屏障，然后当前线程被阻塞。 CyclicBarrier还提供一个更高级的构造函数CyclicBarrier(int parties，Runnable barrier Action)，用于在线程到达屏障时，优先执行barrier Action这个Runnable对象，方便处理更复杂的业务场景。
| public CyclicBarrier(int parties) { this(parties, null); } public CyclicBarrier(int parties, Runnable barrierAction) { if (parties <= 0) throw new IllegalArgumentException(); this.parties = parties; this.count = parties; this.barrierCommand = barrierAction; } |
实现原理，在CyclicBarrier的内部定义了一个Lock对象（ReentrantLock），每当一个线程调用CyclicBarrier的await()方法时，将剩余拦截的线程数减一，然后判断剩余拦截数是否为0，如果不是，进入Lock对象的条件队列等待。如果是，执行barrierAction对象的Runnable方法，然后将所的条件队列中的所有线程放入锁等待队列中，这些线程会依次获取锁，释放锁，接着先从await()方法返回，在从CyclicBarrier的await()方法返回。
| /** The lock for guarding barrier entry */ private final ReentrantLock lock = new ReentrantLock(); |
await()源码：
| public int await() throws InterruptedException, BrokenBarrierException { try { return dowait(false, 0L); } catch (TimeoutException toe) { throw new Error(toe); // cannot happen } } |
dowait源码：
| /** * Main barrier code, covering the various policies. */ 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; 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) 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(); } } |
| private void nextGeneration() { // signal completion of last generation trip.signalAll(); // set up next generation count = parties; generation = new Generation(); } /** * Sets current barrier generation as broken and wakes up everyone. * Called only while holding lock. */ private void breakBarrier() { generation.broken = true; count = parties; trip.signalAll(); } nextGeneration和breakBarrier方法都可以停止阻塞。 |
CyclicBarrier主要用于一组线程之间的相互等待，而CountDownLatch一般用于一组线程等待另一组线程。实际上可以通过CountDownLatch的countDown()和await()来实现CyclicBarrier的功能。 即CountDownLatch中的countDown()和await() = CyclicBarrier中的await()。注意在一个线程中先调用countDown()再调用await() CyclicBarrier对象可以重复使用，重用之前应当调用CyclicBarrier的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(); } } |
CyclicBarrier使用：
| package com.fpc.Test; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.Random; public class CyclicBarrierTest { private CyclicBarrier cyclicBarrier = new CyclicBarrier(4); private Random rnd = new Random(); class taskDemo implements Runnable{ private String taskId; public taskDemo( String taskId ) { this.taskId = taskId; } @Override public void run() { try { int time = rnd.nextInt(1000); Thread.sleep(time); System.out.println(” Thread : ” + taskId + ” sleep : ” + time + “ms”); try { cyclicBarrier.await(); System.out.println(” Thread : ” + taskId + ” sleep is over”); } catch (BrokenBarrierException e) { // TODO Auto-generated catch block e.printStackTrace(); } } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } // CyclicBarrier cyclicBarrier = new CyclicBarrier(); public static void main( String[] args ) { CyclicBarrierTest c = new CyclicBarrierTest(); ExecutorService pool = Executors.newCachedThreadPool(); pool.submit(c.new taskDemo(“1”)); pool.submit(c.new taskDemo(“2”)); pool.submit(c.new taskDemo(“3”)); pool.submit(c.new taskDemo(“4”)); } } |
运行结果：
| Thread : 1 sleep : 102ms Thread : 3 sleep : 254ms Thread : 4 sleep : 394ms Thread : 2 sleep : 943ms Thread : 2 sleep is over Thread : 1 sleep is over Thread : 4 sleep is over Thread : 3 sleep is over |
如果构造CyclicBarrier时，给传的大小是5，但是你进入屏障的线程数只有4个，那么会发生什么现象？ 这些4个线程都无法结束，因为CyclicBarrier还在等待第5个线程结束，但此时根本没有第5个线程，所以之前的4个线程根本无法结束。
| Thread : 3 sleep : 166ms Thread : 4 sleep : 281ms Thread : 2 sleep : 444ms Thread : 1 sleep : 776ms |
那么如果构造CyclicBarrier时，给传递的参数是3呢，但此时有4个线程进入屏障呢？ 结果是其中三个线程会执行然后结束，第四个线程永远无法结束，这是因为CyclicBarrier是可以循环利用的。 执行结果：
| Thread : 3 sleep : 500ms Thread : 1 sleep : 567ms Thread : 2 sleep : 912ms Thread : 2 sleep is over Thread : 3 sleep is over Thread : 1 sleep is over Thread : 4 sleep : 988ms |
