JAVA并发，CyclicBarrier

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的理解太重要了我认为。