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的用处差不多）

 package com.xt.thinks21_7;

 //: concurrency/HorseRace.java
 // Using CyclicBarriers.
 import java.util.concurrent.*;
 import java.util.*;

 /**
  * 马儿类
  * @author Administrator
  *
  */
 class Horse implements Runnable {
     private static int counter = 0;
     private final int id = counter++;
     private int strides = 0;
     private static Random rand = new Random(47);
     private static CyclicBarrier barrier;

     public Horse(CyclicBarrier b) {
         barrier = b;
     }

     public synchronized int getStrides() {
         return strides;
     }

     public void run() {
         try {
             while (!Thread.interrupted()) {
                 synchronized (this) {
                     //马儿奔跑的不熟，可能是0步，1步，2步
                     strides += rand.nextInt(3); // Produces 0, 1 or 2
                 }
                 //当前线程加入
                 barrier.await();
                 /*
                  * await的源码
                  *  public int await() throws InterruptedException, BrokenBarrierException {
                         try {
                             return dowait(false, 0L);
                         } catch (TimeoutException toe) {
                             throw new Error(toe); // cannot happen
                         }
                     }

                     dowait的源码:
                     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;
                                      */

                 //这里需要注意，判断了CyclicBarrier构造器中的runnable接口是否为空，不为空回调run方法
 //                                    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();
                         }
                  */
             }
         } catch (InterruptedException e) {
             // A legitimate way to exit
         } catch (BrokenBarrierException e) {
             // This one we want to know about
             throw new RuntimeException(e);
         }
     }

     /**
      * 打印马儿id
      */
     public String toString() {
         return "Horse " + id + " ";
     }

     /**
      * 打印马儿奔跑轨迹
      */
     public String tracks() {
         StringBuilder s = new StringBuilder();
         for (int i = 0; i < getStrides(); i++)
             s.append("*");
         s.append(id);
         return s.toString();
     }
 }

 /**
  * 马儿奔跑的类
  * @author Administrator
  *
  */
 public class HorseRace {
     static final int FINISH_LINE = 75;
     private List<Horse> horses = new ArrayList<Horse>();
     private ExecutorService exec = Executors.newCachedThreadPool();
     private CyclicBarrier barrier;

     public HorseRace(int nHorses, final int pause) {
         //CyclicBarrier构造器，第二个参数为回调接口，触发条件是await计数到0的时候，也就是所有线程已经加入CyclicBarrier
         barrier = new CyclicBarrier(nHorses, new Runnable() {
             public void run() {
                 StringBuilder s = new StringBuilder();
                 //打印栅栏
                 for (int i = 0; i < FINISH_LINE; i++)
                     s.append("="); // The fence on the racetrack
                 System.out.println(s);
                 //打印所有马儿的奔跑轨迹
                 for (Horse horse : horses)
                     System.out.println(horse.tracks());
                 //如果有一个马儿奔跑到了终点，则取消执行器执行所有线程了
                 for (Horse horse : horses)
                     if (horse.getStrides() >= FINISH_LINE) {
                         System.out.print(horse + "won!");
                         exec.shutdownNow();
                         return;
                     }
                 //每一次所有马儿奔跑一次之后休眠时间
                 try {
                     TimeUnit.MILLISECONDS.sleep(pause);
                 } catch (InterruptedException e) {
                     System.out.println("barrier-action sleep interrupted");
                 }
             }
         });
         //加入所有马儿到线程列表，执行器执行线程列表（所有马儿奔跑）
         for (int i = 0; i < nHorses; i++) {
             Horse horse = new Horse(barrier);
             horses.add(horse);
             exec.execute(horse);
         }
     }

     public static void main(String[] args) {
         int nHorses = 7;
         int pause = 200;
         if (args.length > 0) { // Optional argument
             int n = new Integer(args[0]);
             nHorses = n > 0 ? n : nHorses;
         }
         if (args.length > 1) { // Optional argument
             int p = new Integer(args[1]);
             pause = p > -1 ? p : pause;
         }
         new HorseRace(nHorses, pause);

     }
 } /* (Execute to see output) */// :~

总结：

thinking in java上面的代码例子都是精华，不是网络上一般的博主能够写出来的，理解了对自己很有好处，及时一个知识点花上一个小时也可以。

但是美中不足的是：thinking in java中翻译过来有些地方阐述的不是很清楚（可能也是原著就没阐述清楚），例如。它主要的方法就是一个：await()。await() 方法没被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier 上面阻塞的线程开始运行。在这之后，如果再次调用 await() 方法，计数就又会变成 N-1，新一轮重新开始，这便是 Cyclic 的含义所在。这段话对CyclicBarrier的理解太重要了我认为。