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;
  22.                     if (command != null)
  23.                         command.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();
  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.     }
  69. private void doSignalAll(Node first) {
  70.             lastWaiter = firstWaiter = null;
  71.             do {
  72.                 Node next = first.nextWaiter;
  73.                 first.nextWaiter = null;
  74.                 transferForSignal(first);
  75.                 first = next;
  76.             } while (first != null);
  77.         }
  80. final boolean transferForSignal(Node node) {
  81.         /*
  82.          * If cannot change waitStatus, the node has been cancelled.
  83.          */
  84.         if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
  85.             return false;
  87.         /*
  88.          * Splice onto queue and try to set waitStatus of predecessor to
  89.          * indicate that thread is (probably) waiting. If cancelled or
  90.          * attempt to set waitStatus fails, wake up to resync (in which
  91.          * case the waitStatus can be transiently and harmlessly wrong).
  92.          */
  93.         Node p = enq(node);
  94.         int ws = p.waitStatus;
  95.         if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
  96.             LockSupport.unpark(node.thread);
  97.         return true;
  98.     }

流程

03-26 CyclicBarrier执行流程 - 图1