CyclicBarrier源码分析

首先分析CyclicBarrier的核心方法await

    public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen;
        }
    }

    public int await(long timeout, TimeUnit unit)
        throws InterruptedException,
               BrokenBarrierException,
               TimeoutException {
        return dowait(true, unit.toNanos(timeout));
    }

可以看出不管是否带超时，但将会调用方法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;
                   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();
        }
    }

在代码执行前，将会使用一个ReentrantLock对象(CyclicBarrier的实例域)进行加锁，保证屏障的线程安全。

final Generation g = generation;

if (g.broken)
    throw new BrokenBarrierException();

if (Thread.interrupted()) {
    breakBarrier();
    throw new InterruptedException();
}

接下来将检查屏障是否被打破，还有检查当前线程是否被中断
那么是如何检查屏障是否被打破，使用到的即是Generation对象，将根据该对象的实例域broken(一个布尔类型的值)来判断是否被打破

private static class Generation {
    boolean broken = false;
}

Generation类只有一个布尔类型的实例域broken，用于作为屏障是否打破的标记

int index = --count;
if (index == 0) {  // tripped
    boolean ranAction = false;
    try {
        final Runnable command = barrierCommand;
        if (command != null)
            command.run();
            ranAction = true;
            nextGeneration();
            return 0;
        } finally {
            if (!ranAction)
                breakBarrier();
        }
    }

接下来将开始计数，将屏障计数减一，然后判断是否为0，若为0则全部线程到达屏障，屏障将打开
在打开屏障前，将会执行CyclicBarrier的Runnable实例域barrierCommand，barrierCommand就是在构造函数中传参进行来的Runnable对象，即用户想要在所有线程到达后，而在屏障打开前锁要执行的任务
可以看出，如上说的一样，改任务是在屏障打开前执行的，而且是由最后一个到达屏障的线程执行

接下来可以看看打开屏障的方法nextGeneration

private void nextGeneration() {
    // signal completion of last generation
    trip.signalAll();
    // set up next generation
    count = parties;
    generation = new Generation();
}

trip是一个Condition对象

private final Condition trip = lock.newCondition();

用于实现屏障的阻塞功能，当然，在所有线程到达屏障后，将会唤醒所有阻塞的线程
count是用于到达屏障的计数，而parties则是指定屏障的需要线程到达的数量，当屏障打开时，count将复原为需要到达数量
最后，将重新实例化一个Generation对象，然后替换掉原来的。
前面提到，Generation有个布尔类型实例域broken用于判断屏障是否被打破，那么直接用一个boolean类型不就行了吗，为什么还需要定义个Generation类。Generation所代表的是”一代”，而屏障需要标记的，不单只是是否被打破，还要标记屏障是否完成了一轮的任务，即被正常打开，显然这样需要两个标记值。而使用Generation对象用作表示每轮的屏障的状态，当验证屏障是否被打开时，只需要验证是否为同一个Generation对象即可。如果不抽象出一个Generation类，对于这种屏障状态的表达，将显得复杂而难以控制

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();
    }
}

若然到达屏障的不是最后一个线程，将进入一个死循环，并且根据是否带超时，执行Condition对象的await方法进行阻塞，以此等待其他线程到达屏障，该过程在死循环中执行，是为了防止线程意外唤醒，破坏屏障的规则
若然线程在阻塞的过程中被中断，将会判断屏障是否完好，若然完好，则会将屏障打破，唤醒其他线程，这种情况是任何一个到达屏障的线程被中断都会引发的。若然线程在中断时，屏障已经打开或者被打破了，将再次执行当前线程的中断操作，而不做更多的操作
线程从阻塞中返回后，将有三个判断
第一个判断判断于屏障是否被打破，则线程是因为屏障被打破而唤醒的，抛出BrokenBarrierException异常
第二个判断是判断generation是否为同一个对象，则判断”本轮操作”完成了吗，屏障被正常打开，将返回一个整型index，index表达的是线程到达屏障的顺序，数值越大越早到达，index为0则表明该线程是最后一个到达的
第三个判断是用于超时判断，若线程由于超时而被唤醒，将会打破屏障，唤醒其他线程，并且抛出TimeoutException

打破屏障的方法

private void breakBarrier() {
    generation.broken = true;
    count = parties;
    trip.signalAll();
}

屏障打破后将唤醒所有在屏障中等待的线程，而且被打破后需要重置屏障，否则不能再使用该屏障
重置屏障方法

public void reset() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        breakBarrier();   // 打破当前屏障
        nextGeneration(); // 下一代，即重新开始屏障计数
    } finally {
        lock.unlock();
    }
}