他的作用时使一组线程到达一个屏障点（也可以叫同步点）时会被阻塞，直到最后同一个线程到达屏障时，屏障就会开门，所以的被拦截的线程才会继续执行。

构造器

  1.     public CyclicBarrier(int parties, Runnable barrierAction) {
  2.         if (parties <= 0) throw new IllegalArgumentException();
  3.         this.parties = parties;
  4.         this.count = parties;
  5.         this.barrierCommand = barrierAction;
  6.     }

构造器可知CyclicBarrier创建时，会有一个阻塞线程数和一个阻塞后运行的线程。

await()同步点

  1.     public int await() throws InterruptedException, BrokenBarrierException {
  2.         try {
  3.             return dowait(false, 0L);//nanos时等待时间
  4.         } catch (TimeoutException toe) {
  5.             throw new Error(toe); // cannot happen
  6.         }
  7.     }
  1.  private int dowait(boolean timed, long nanos)
  2.         throws InterruptedException, BrokenBarrierException,
  3.                TimeoutException {
  4.         final ReentrantLock lock = this.lock;//维护了一把重入锁
  5.         lock.lock();//线程要先获取锁
  6.         try {
  7.             final Generation g = generation;
  9.             if (g.broken)
  10.                 throw new BrokenBarrierException();
  12.             if (Thread.interrupted()) {
  13.                 breakBarrier(); //破环屏障
  14.                 throw new InterruptedException();
  15.             }
  17.             int index = --count;//已经执行过到这里的次数，由于这里已经加锁所以不会有并发问题
  18.             if (index == 0) {  // tripped，所以的线程都到了这个屏障点
  19.                 boolean ranAction = false;
  20.                 try {
  21.                     final Runnable command = barrierCommand;//获取屏障CyclicBarrier构造器的线程
  22.                     if (command != null)
  23.                         command.run();//由最后一个线程调用run方法（这里没有新建一个线程）
  24.                     ranAction = true;
  25.                     nextGeneration();
  26.                     return 0;
  27.                 } finally {
  28.                     if (!ranAction)
  29.                         breakBarrier();//破环屏障
  30.                 }
  31.             }
  33.             // loop until tripped, broken, interrupted, or timed out 循环直到触发、损坏、中断 或者超时
  34.             for (;;) {
  35.                 try {
  36.                     if (!timed)//不需要超时等待
  37.                         trip.await();//condition阻塞在这里，让其他线程抢占lock
  38.                     else if (nanos > 0L)
  39.                         nanos = trip.awaitNanos(nanos);//超时阻塞，等待被唤醒或者超时
  40.                 } catch (InterruptedException ie) {//阻塞时候被中断。
  41.                     if (g == generation && ! g.broken) {
  42.                         breakBarrier();//破环屏障
  43.                         throw ie;
  44.                     } else {
  45.                         // We're about to finish waiting even if we had not
  46.                         // been interrupted, so this interrupt is deemed to
  47.                         // "belong" to subsequent execution.
  48.                         Thread.currentThread().interrupt();//回复中断标识
  49.                     }
  50.                 }
  52.                 if (g.broken)
  53.                     throw new BrokenBarrierException();
  55.                 if (g != generation)
  56.                     return index;
  58.                 if (timed && nanos <= 0L) {
  59.                     breakBarrier();
  60.                     throw new TimeoutException();
  61.                 }
  62.             }
  63.         } finally {
  64.             lock.unlock();
  65.         }
  66.     }

可以看出，运行到cyclicbarrier.await()方法后会维护一把重入锁，每个线程进来计算器-1，并通过condition阻止。当计算器=0，及最后一个线程进来的时候，会执行cyclicbarrier的方法。执行完成会调用nextGeneration()唤醒其他所以的线程

  1.     private void nextGeneration() {
  2.         // signal completion of last generation
  3.         trip.signalAll();
  4.         // set up next generation
  5.         count = parties;
  6.         generation = new Generation();
  7.     }