源码分析--CyclicBarrier

概述

CyclicBarrier 是并发包中的一个工具类，它的典型应用场景为：几个线程执行完任务后，执行另一个线程（回调函数，可选），然后继续下一轮，如此往复。它与CountDownLatch很类似，但又不同，CountDownLatch需要调用countDown()方法触发事件，而CyclicBarrier不需要。

方法

使用样例：

public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                System.out.println("before");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("after");
            }).start();
        }
    }
}    

使用一个CyclicBarrier使得三个线程保持同步，当三个线程同时到达cyclicBarrier.await();处大家再一起往下运行。

源码分析

构造器：

    this(parties, null);
}

// 有回调函数
public CyclicBarrier(int parties, Runnable barrierAction) {
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties;
    this.count = parties;
    this.barrierCommand = barrierAction;
}

CyclicBarrier 有两个构造器，其中后者可以传入一个回调函数（barrierAction），parties 表示调用 await 的线程数。

成员变量

// 重入锁
private final ReentrantLock lock = new ReentrantLock();
// 条件锁，名称为trip，绊倒的意思，可能是指线程来了先绊倒，等达到一定数量了再唤醒
private final Condition trip = lock.newCondition();
// 需要等待的线程数量
private final int parties;
// 当唤醒的时候执行的命令
private final Runnable barrierCommand;
// 代
private Generation generation = new Generation();
// 当前这一代还需要等待的线程数
private int count;

内部类

private static class Generation {
    boolean broken = false;
}

常用方法：

// 阻塞式等待
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));
}

可以看到两个 await 方法都是调用 dowait 方法来实现的（该方法也是 CyclicBarrier 的核心方法），如下：

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

        // count 减 1
        int index = --count;
        if (index == 0) {  // tripped
            // count 减到 0 时触发的操作
            boolean ranAction = false;
            try {
                // 传入的回调函数
                final Runnable command = barrierCommand;
                if (command != null)
                    // 若传了回调函数，则执行回调函数
                    // PS: 由此可知，回调函数由最后一个执行结束的线程执行
                    command.run();
                ranAction = true;
                // 进入下一代（下一轮操作）
                nextGeneration();
                return 0;
            } finally {
                if (!ranAction)
                    breakBarrier();
            }
        }

        // loop until tripped, broken, interrupted, or timed out
        for (;;) {
            try {
                // count 不为 0 时，当前线程进入等待状态
                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();
    }
}

nextGeneration 和 breakBarrier:

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

// 破坏屏障
private void breakBarrier() {
    generation.broken = true;
    count = parties;
    trip.signalAll();
}

dowait()方法里的整个逻辑分成两部分：

（1）最后一个线程走上面的逻辑，当count减为0的时候，打破栅栏，它调用nextGeneration()方法通知条件队列中的等待线程转移到AQS的队列中等待被唤醒，并进入下一代。

（2）非最后一个线程走下面的for循环逻辑，这些线程会阻塞在condition的await()方法处，它们会加入到条件队列中，等待被通知，当它们唤醒的时候已经更新换“代”了，这时候返回。

小结

（1）CyclicBarrier会使一组线程阻塞在await()处，当最后一个线程到达时唤醒（只是从条件队列转移到AQS队列中）前面的线程大家再继续往下走；
（2）CyclicBarrier不是直接使用AQS实现的一个同步器；
（3）CyclicBarrier基于ReentrantLock及其Condition实现整个同步逻辑；