CyclicBarrier 翻译过来叫循环栅栏、循环障碍什么的（还是有点别扭的。所以还是别翻译了，只可意会不可言传啊）。它主要的方法就是一个：await()。await() 方法没被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier 上面阻塞的线程开始运行。在这之后，如果再次调用 await() 方法，计数就又会变成 N-1，新一轮重新开始，这便是 Cyclic 的含义所在。
CyclicBarrier 的使用并不难，但需要主要它所相关的异常。除了常见的异常，CyclicBarrier.await() 方法会抛出一个独有的 BrokenBarrierException。这个异常发生在当某个线程在等待本 CyclicBarrier 时被中断或超时或被重置时，其它同样在这个 CyclicBarrier 上等待的线程便会受到 BrokenBarrierException。意思就是说，同志们，别等了，有个小伙伴已经挂了，咱们如果继续等有可能会一直等下去，所有各回各家吧。
CyclicBarrier.await() 方法带有返回值，用来表示当前线程是第几个到达这个 Barrier 的线程。
和 CountDownLatch 一样，CyclicBarrier 同样可以可以在构造函数中设定总计数值。与 CountDownLatch 不同的是，CyclicBarrier 的构造函数还可以接受一个 Runnable，会在 CyclicBarrier 被释放时执行。
“NOTE: CyclicBarrier 的功能也可以由 CountDownLatch 来实现
上面的内容参考自：http://developer.51cto.com/art/201403/432095.htm
下面的例子引用thinking in java（网络上的简单例子体现不出CyclicBarrier存在的意义，和CountDownLatch的用处差不多）
1 package com.xt.thinks21_7; 2 3 //: concurrency/HorseRace.java 4 // Using CyclicBarriers. 5 import java.util.concurrent.*; 6 import java.util.*; 7 8 /** 9 * 马儿类 10 * @author Administrator 11 * 12 */ 13 class Horse implements Runnable { 14 private static int counter = 0; 15 private final int id = counter++; 16 private int strides = 0; 17 private static Random rand = new Random(47); 18 private static CyclicBarrier barrier; 19 20 public Horse(CyclicBarrier b) { 21 barrier = b; 22 } 23 24 public synchronized int getStrides() { 25 return strides; 26 } 27 28 public void run() { 29 try { 30 while (!Thread.interrupted()) { 31 synchronized (this) { 32 //马儿奔跑的不熟，可能是0步，1步，2步 33 strides += rand.nextInt(3); // Produces 0, 1 or 2 34 } 35 //当前线程加入 36 barrier.await(); 37 /* 38 * await的源码 39 * public int await() throws InterruptedException, BrokenBarrierException { 40 try { 41 return dowait(false, 0L); 42 } catch (TimeoutException toe) { 43 throw new Error(toe); // cannot happen 44 } 45 } 46 47 dowait的源码: 48 private int dowait(boolean timed, long nanos) 49 throws InterruptedException, BrokenBarrierException, 50 TimeoutException { 51 final ReentrantLock lock = this.lock; 52 lock.lock(); 53 try { 54 final Generation g = generation; 55 56 if (g.broken) 57 throw new BrokenBarrierException(); 58 59 if (Thread.interrupted()) { 60 breakBarrier(); 61 throw new InterruptedException(); 62 } 63 64 int index = --count; 65 if (index == 0) { // tripped 66 boolean ranAction = false; 67 try { 68 final Runnable command = barrierCommand; 69 */ 70 71 //这里需要注意，判断了CyclicBarrier构造器中的runnable接口是否为空，不为空回调run方法 72 // if (command != null) 73 // command.run(); 74 75 /* 76 ranAction = true; 77 nextGeneration(); 78 return 0; 79 } finally { 80 if (!ranAction) 81 breakBarrier(); 82 } 83 } 84 85 // loop until tripped, broken, interrupted, or timed out 86 for (;;) { 87 try { 88 if (!timed) 89 trip.await(); 90 else if (nanos > 0L) 91 nanos = trip.awaitNanos(nanos); 92 } catch (InterruptedException ie) { 93 if (g == generation && ! g.broken) { 94 breakBarrier(); 95 throw ie; 96 } else { 97 // We're about to finish waiting even if we had not 98 // been interrupted, so this interrupt is deemed to 99 // "belong" to subsequent execution. 100 Thread.currentThread().interrupt(); 101 } 102 } 103 104 if (g.broken) 105 throw new BrokenBarrierException(); 106 107 if (g != generation) 108 return index; 109 110 if (timed && nanos <= 0L) { 111 breakBarrier(); 112 throw new TimeoutException(); 113 } 114 } 115 } finally { 116 lock.unlock(); 117 } 118 */ 119 } 120 } catch (InterruptedException e) { 121 // A legitimate way to exit 122 } catch (BrokenBarrierException e) { 123 // This one we want to know about 124 throw new RuntimeException(e); 125 } 126 } 127 128 /** 129 * 打印马儿id 130 */ 131 public String toString() { 132 return "Horse " + id + " "; 133 } 134 135 /** 136 * 打印马儿奔跑轨迹 137 */ 138 public String tracks() { 139 StringBuilder s = new StringBuilder(); 140 for (int i = 0; i < getStrides(); i++) 141 s.append("*"); 142 s.append(id); 143 return s.toString(); 144 } 145 } 146 147 /** 148 * 马儿奔跑的类 149 * @author Administrator 150 * 151 */ 152 public class HorseRace { 153 static final int FINISH_LINE = 75; 154 private List<Horse> horses = new ArrayList<Horse>(); 155 private ExecutorService exec = Executors.newCachedThreadPool(); 156 private CyclicBarrier barrier; 157 158 public HorseRace(int nHorses, final int pause) { 159 //CyclicBarrier构造器，第二个参数为回调接口，触发条件是await计数到0的时候，也就是所有线程已经加入CyclicBarrier 160 barrier = new CyclicBarrier(nHorses, new Runnable() { 161 public void run() { 162 StringBuilder s = new StringBuilder(); 163 //打印栅栏 164 for (int i = 0; i < FINISH_LINE; i++) 165 s.append("="); // The fence on the racetrack 166 System.out.println(s); 167 //打印所有马儿的奔跑轨迹 168 for (Horse horse : horses) 169 System.out.println(horse.tracks()); 170 //如果有一个马儿奔跑到了终点，则取消执行器执行所有线程了 171 for (Horse horse : horses) 172 if (horse.getStrides() >= FINISH_LINE) { 173 System.out.print(horse + "won!"); 174 exec.shutdownNow(); 175 return; 176 } 177 //每一次所有马儿奔跑一次之后休眠时间 178 try { 179 TimeUnit.MILLISECONDS.sleep(pause); 180 } catch (InterruptedException e) { 181 System.out.println("barrier-action sleep interrupted"); 182 } 183 } 184 }); 185 //加入所有马儿到线程列表，执行器执行线程列表（所有马儿奔跑） 186 for (int i = 0; i < nHorses; i++) { 187 Horse horse = new Horse(barrier); 188 horses.add(horse); 189 exec.execute(horse); 190 } 191 } 192 193 public static void main(String[] args) { 194 int nHorses = 7; 195 int pause = 200; 196 if (args.length > 0) { // Optional argument 197 int n = new Integer(args[0]); 198 nHorses = n > 0 ? n : nHorses; 199 } 200 if (args.length > 1) { // Optional argument 201 int p = new Integer(args[1]); 202 pause = p > -1 ? p : pause; 203 } 204 new HorseRace(nHorses, pause); 205 206 } 207 } /* (Execute to see output) */// :~
总结：
thinking in java上面的代码例子都是精华，不是网络上一般的博主能够写出来的，理解了对自己很有好处，及时一个知识点花上一个小时也可以。
但是美中不足的是：thinking in java中翻译过来有些地方阐述的不是很清楚（可能也是原著就没阐述清楚），例如。它主要的方法就是一个：await()。await() 方法没被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier 上面阻塞的线程开始运行。在这之后，如果再次调用 await() 方法，计数就又会变成 N-1，新一轮重新开始，这便是 Cyclic 的含义所在。这段话对CyclicBarrier的理解太重要了我认为。