CyclicBarrier源码分析

CyclicBarrier源码分析

CyclicBarrier的作用是让一组线程互相等待至某个状态后并行执行（相对外部来说是并行，其实内部还是串行）

基本的使用方法是创建一个CyclicBarrier实例，并且指定parties的个数，然后线程依次调用CyclicBarrier的await()方法让自己进入等待状态，当最后一个线程进入await()方法时，将会唤醒所有正在等待的线程，并行执行。

CyclicBarrier虽然也是同步器，但是并非直接通过AQS来进行实现的，而是借助了ReentrantLock以及Condition来进行实现。

CyclicBarrier的结构

public class CyclicBarrier {
    
    /**
     * 存在一个Generation静态内部类
     */ 
    private static class Generation {
        boolean broken = false; // 标识CyclicBarrier是否被破坏
    }

    private final ReentrantLock lock = new ReentrantLock();
    
    private final Condition trip = lock.newCondition(); // 与ReentrantLock绑定的Condition实例

    private final int parties; // 用于记录一共有多少个线程需要等待

    private final Runnable barrierCommand; // 由最后一个进入await()方法的线程进行调用

    private Generation generation = new Generation();

    private int count; // 用于记录还需要多少个线程进行等待

    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }

    public CyclicBarrier(int parties) {
        this(parties, null);
    }

    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));
    }
   
    private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        // ......
    }
    
    // 其他省略
}

可以看到CyclicBarrier存在全局的lock、trip、parties、count、barrierCommand以及generation属性，其中parties属性用于记录一共有多少个线程需要等待，而count用于记录还需要多少个线程进行等待。

同时CyclicBarrier中定义了一个Generation静态内部类，该内部类只有一个broken全局属性，用于标识CyclicBarrier是否被破坏，默认为false。

同时CyclicBarrier的构造方法会初始化全局的parties、count以及barrierCommand属性（CyclicBarrier初始化后，count的数量等于parties的数量）

await()方法

由于当创建CyclicBarrier实例之后，线程需要依次调用CyclicBarrier的await()方法让自己进入等待状态，因此从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));
}

await()方法存在两个重载，区别是一个支持超时，一个不支持超时，最终都会调用dowait()方法（使用timed参数表示是否有超时限制，如果timed参数为true则需要传递具体的超时时间）

dowait()方法

private int dowait(boolean timed, long nanos)
    throws InterruptedException, BrokenBarrierException,
           TimeoutException {
    // 获取全局的ReentrantLock实例，并进行加锁           
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 获取全局的Generation实例，如果Generation中的broken属性为true则表示CyclicBarrier已经被破坏，则直接抛出异常（默认是false）
        final Generation g = generation;

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

        // 如果线程已经被设置了中断标识，则调用breakBarrier()方法，破坏CyclicBarrier
        if (Thread.interrupted()) {
            breakBarrier();
            throw new InterruptedException(); // 抛出异常
        }

        // index属性用于记录还需要多少个线程进行等待
        int index = --count;
        // 如果index等于0，表示当前线程是最后一个进入await()方法的线程，如果barrierCommand不为空，那么执行barrierCommand的run()方法，然后调用nextGeneration()方法，唤醒在指定Condition实例中等待的所有线程，并重置CyclicBarrier，然后线程直接返回，做自己的事情
        if (index == 0) {  // 最后一个线程走这个逻辑
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                if (command != null)
                    command.run();
                ranAction = true;
                nextGeneration();
                return 0;
            } finally {
                // 如果在执行barrierCommand的run()方法时抛出异常，那么ranAction标识为false，那么需要调用breakBarrier()方法，破坏CyclicBarrier
                if (!ranAction)
                    breakBarrier();
            }
        }

        // 如果非最后一个线程那么将会往下执行
        
        // 循环
        for (;;) {
            try {
                // 如果没有超时限制，那么直接调用Condition实例的await()方法，让线程在指定的Condition实例中进行等待，并释放掉它拥有的锁
                // 如果有超时限制，那么调用Condition实例的awaitNanos()方法，至多让线程在指定的Condition实例中等待指定的时间，该方法返回线程被唤醒后剩余的毫秒数（超时返回小于等于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 {
                    Thread.currentThread().interrupt();
                }
            }

            // 当线程被唤醒后将会串行执行以下的逻辑
            
            // 如果发现CyclicBarrier被破坏了，那么就抛出异常
            if (g.broken)
                throw new BrokenBarrierException();

            // 正常情况下，当调用了nextGeneration()方法之后，generation引用就指向一个新的Generation实例，因此g!=generation，那么线程直接返回，做自己的事情
            if (g != generation)
                return index;

            // 如果线程在Condition实例等待的过程中由于达到了超时时间而被唤醒了，那么将会调用breakBarrier()方法，破坏CyclicBarrier
            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException(); // 抛出异常
            }
        }
    } finally {
        lock.unlock(); // 解锁
    }
}

当线程进入dowait()方法后，需要获取锁，如果当前线程并非最后一个进入await()方法的线程，那么将会在指定的Condition实例中进行等待，然后释放掉它拥有的锁，如果当前线程是最后一个进入await()方法的线程（index==0，表示还需要0个线程进行等待），如果barrierCommand不为空，那么将会执行barrierCommand的run()方法，最后调用nextGeneration()方法。

如果在执行dowait()方法的过程中，线程已经被设置了中断标识，或者最后一个线程在执行barrierCommand的run()方法时抛出异常，或者在指定Condition实例等待的线程由于达到了超时时间而被唤醒，那么都会调用breakBarrier()方法。

nextGeneration()方法

private void nextGeneration() {
    // 唤醒在指定Condition实例中等待的所有线程
    trip.signalAll();
    // 将count的数量设置成parties
    count = parties;
    // 将generation引用指向一个新的Generation实例
    generation = new Generation();
}

nextGeneration()方法用于指向下一个Generation，该方法将会唤醒在指定Condition实例中等待的所有线程，然后将count的数量设置成parties，恢复成CyclicBarrier初始化后的状态，最后将generation引用指向一个新的Generation实例。

breakBarrier()方法

private void breakBarrier() {
    // 将Generation实例的broken属性设置为true，表示CyclicBarrier已经被破坏
    generation.broken = true;
    // 将count的数量设置回parties
    count = parties;
    // 唤醒在指定Condition实例中等待的所有线程
    trip.signalAll();
}

breakBarrier()方法用于破坏CyclicBarrier，将Generation实例的broken属性设置为true，表示CyclicBarrier已经被破坏，然后将count的数量设置成parties，最后唤醒在指定Condition实例中等待的所有线程。

reset()方法

public void reset() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        breakBarrier(); // 感觉是多余的
        nextGeneration(); // 指向下一个Generation
    } finally {
        lock.unlock();
    }
}

reset()方法用于重置CyclicBarrier，其根本是将generation引用指向一个新的Generation实例。

流程总结

1.当创建了一个CyclicBarrier实例之后，线程需要依次调用CyclicBarrier的await()方法，让自己进入等待状态。

2.await()方法又会调用dowait()方法，当线程进入dowait()方法后，需要获取锁，如果当前线程并非最后一个进入await()方法的线程，那么将会在指定的Condition实例中进行等待，然后释放掉它拥有的锁，如果当前线程是最后一个进入await()方法的线程（index==0，表示还需要0个线程进行等待），如果barrierCommand不为空，那么将会执行barrierCommand的run()方法，最后调用nextGeneration()方法。

3.nextGeneration()方法用于指向下一个Generation，该方法将会唤醒在指定Condition实例中等待的所有线程，然后将count的数量设置成parties，恢复成CyclicBarrier初始化后的状态，最后将generation引用指向一个新的Generation实例，当最后一个线程执行完nextGeneration()方法后，将会直接返回，做自己的事情，最后释放掉它拥有的锁。

4.当被唤醒的线程依次获取到锁后，将会继续往下执行，如果判断到generation引用已经指向一个新的Generation实例，那么直接返回，做自己的事情，最后释放掉它拥有锁。

5.如果在执行dowait()方法的过程中，线程已经被设置了中断标识，或者最后一个线程在执行barrierCommand的run()方法时抛出异常，或者在指定Condition实例等待的线程由于达到了超时时间而被唤醒，那么都会调用breakBarrier()方法，破坏CyclicBarrier，将Generation实例的broken属性设置为true，表示CyclicBarrier已经被破坏，然后将count的数量设置成parties，最后唤醒在指定Condition实例中等待的所有线程。

6.当被唤醒的线程依次获取到锁后，将会继续往下执行，如果判断到Generation实例的broken属性被设置了true，也就是CyclicBarrier已经被破坏，那么将会直接抛出异常，最后释放掉它拥有的锁。

7.当CyclicBarrier被破坏后是不能够进行复用的，因为Generation的broken属性已经被设置成true，因此需要先调用一次reset()方法进行重置。

FAQ

为什么说CyclicBarrier是可以复用的?

因为当最后一个线程进入await()方法，将会调用nextGeneration()方法，该方法除了唤醒在指定Condition中等待的线程之外，还会将count的数量设置成parties，恢复成CyclicBarrier初始化后的状态，同时将generation引用指向一个新的Generation实例，因此CyclicBarrier是可以复用的，同时需要注意的是，如果CyclicBarrier已经被破坏，那么需要先调用一次reset()方法之后才能够进行复用。