【Java 并发】【九】【AQS】【六】CyclicBarrier栅栏底层机制原理

1  前言

接下来我们来看看CyclicBarrier，也是基于之前讲解的AQS来实现的，建立在AQS体系之上的一个并发工具类，依赖了ReentrantLock。

2  CyclicBarrier是什么

CyclicBarrier，就是一个计数器栅栏，也就是一个计数器开关。
比如CyclicBarrier barrier = new CyclicBarrier(3)，最开始的时候这个栅栏上有3道锁，每次调用barrier.await方法的时候就会减少栅栏上面的一道锁，调用3次await方法的时候就相当于3道锁都清除了，这个时候栅栏就会打开了。如果线程调用了await方法之后，栅栏上面还有锁，那么这个线程就得在那里等着了，等别的哥们也调用await方法清除栅栏上面的锁，直到栅栏上面的所有锁都清除了之后栅栏才会打开。
我们还是写个例子，感受下：

public class CyclicBarrierTest {
    // 声明一个有3道锁的栅栏
    public static CyclicBarrier barrier = new CyclicBarrier(3);
    // 等待通过栅栏的线程
    public static class WaiterThread extends Thread {
        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + "到了，先等着");
                barrier.await();
                System.out.println(Thread.currentThread().getName() + "放行了");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 创建3个等待通过栅栏的线程
        WaiterThread waiter1 = new WaiterThread();
        WaiterThread waiter2 = new WaiterThread();
        WaiterThread waiter3 = new WaiterThread();

        waiter1.start();
        waiter2.start();
        waiter3.start();

        waiter1.join();
        waiter2.join();
        waiter3.join();
        System.out.println("运行结束");
    }
}

只有三个线程都调用了await方法之后，也就是栅栏上面的锁都打开了之后，才放行。
我们上节说CountDownLatch也是类似计数器，那么两者有什么区别呢？
CountDownLatch是一个一次性的开关，相当于门闩上面的所有锁都打开了之后就放行所有人，只要这个门闩打开了就不会再次关上了，也就是门一直是打开的；然而CyclicBarrier就不是了，比如CyclicBarrier barrier = new CyclicBarrier(3); 表示栅栏上面有3道锁。3道锁都被打开了之后，barrier栅栏会放行一次，然后一次放行会放3个人过去，一旦放行了3个人过去之后，这个栅栏又关闭了，栅栏上面又恢复了3道锁的状态，周而复始......
我们画个图来理解下：

CyclicBarrier的大概流程就如上面图所示，假如CyclicBarrier barrier = new CyclicBarrier(3)，创建一个有3道锁的栅栏。
（1）线程1最开始调用await方法减少栅栏的一道锁，但是此时栅栏上面还有2道锁，栅栏还是关闭状态，此时线程1进入等待。
（2）同理线程2调用await方法也一样，当线程3调用await方法的时候刚好把栅栏的最后一道锁解开了，此时栅栏打开了，线程3就会叫醒沉睡的线程1、线程2，让他们也一起通过。
（3）这3个线程通过了之后，栅栏重新关闭，恢复3道锁的状态，一直循环往复

3  CyclicBarrier源码分析

3.1  CyclicBarrier重要属性

先来看一下CyclicBarrier有哪些属性：

public class CyclicBarrier {
    // 内部类，批次
    private static class Generation {
        boolean broken = false;
    }
    // 注意：这里有一个ReentrantLock，说明CyclicBarrier的是基于ReentrantLock实现的
    private final ReentrantLock lock = new ReentrantLock();
    // 这里有一个condition trip，说明CyclicBarrier的实现依赖Condition
    private final Condition trip = lock.newCondition();
    // 这里就是栅栏上面有多少道锁，初始化栅栏是多少，这里的parties就是多少
    private final int parties;
    // 这里有个任务，就是栅栏开启的时候，如果这个任务不是null,则会执行这个任务
    private final Runnable barrierCommand;
    // 批次，栅栏再次关闭之后会进入下一个批次
    private Generation generation = new Generation();
    // 栅栏上面还有多少道锁，比如最开始有3道锁，现在只有1道锁，这时count=1
    private int count;
}

先说一下上面的关键属性：

lock：CyclicBarrier内部有一个ReentrantLock，调用await方法的时候需要去获取锁。
trip：这里是ReentrantLock的Condition，主要用来实现await和signal效果的，之前我们讲解Condition的底层原理的时候讲解过了，不懂的小伙伴，需要回去看一下哦。
parties：这个就是你设置栅栏上面有多少道锁了，创建的时候是多少就是多少道锁，CyclicBarrier barrier = new CyclicBarrier(3)，那么这里的parties = 3；
count：这里就是当前栅栏上面还剩余多少道锁，比如parties = 3，有两个线程调用了barrier.await方法，那么锁减少了2道，那么此时count = 1，说明还剩余1道锁。
generation：这里是实现CyclicBarrier的关键，叫做批次。每次CyclicBarrier打开之后，都会换一个批次，这样CyclicBarrier就可以复用了
barrierCommand：任务，这个属性可以传也可以不传。每次栅栏打开的时候会检查这个属性是不是空，如果不是栅栏打开的时候会运行这个任务。

3.2  CyclicBarrier构造方法

看了CyclicBarrier的关键属性，我们再看一下CyclicBarrier的构造方法：

public CyclicBarrier(int parties) {
    // 这里传递的barrierAction为null，说明栅栏打开的时候没有任务需要做
    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的核心方法await的源码。

3.3  await方法源码

public int await() throws InterruptedException, BrokenBarrierException {
    try {
        // 这里调用了内部的dowait方法
        return dowait(false, 0L);
    } catch (TimeoutException toe) {
        throw new Error(toe); // cannot happen
    }
}

3.3.1  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();
        }
        // 看到这里，就是将剩余锁数量减少1道，即--count
        int index = --count;
        // 如果锁剩余数量为0，说明栅栏打开了
        if (index == 0) { // tripped
            boolean ranAction = false;
            try {
                // 传入的任务是不是null，如果不是空运行一下任务
                final Runnable command = barrierCommand;
                if (command != null)
                    command.run();
                ranAction = true;
                // 到这里，就是换一个批次，会唤醒沉睡队列的线程
                // 这里会调用condition.signalAll唤醒沉睡队列的线程
                nextGeneration();
                return 0;
            } finally {
                if (!ranAction)
                    breakBarrier();
            }
        }

        // 走到这里，说明上面的锁剩余数量index > 0
        for (;;) {
            try {
                if (!timed)
                    // 看这里，发现锁数量大于0，直接调用condition的await方法沉睡了
                    // 等待栅栏打开的时候调用condition.signalAll将它唤醒
                    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();
            // 走到这里，发现自己属于上一个批次，跟当前批次generation不等
            // 直接就返回index了
            if (g != generation)
                return index;

            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException();
            }
        }
    } finally {
        // 释放锁
        lock.unlock();
    }
}

我们拿个例子边画图边分析一下运行过程，方便理解：
假如说CyclicBarrier barrier = new CyclicBarrier(3)，线程1、线程2、线程3分别调用barrier.await方法，则流程如下：
（1）线程1最开始调用CyclicBarrier的await方法，执行流程如下图：

首先第一步是执行ReentrantLock的lock方法获取锁，然后将栅栏剩余锁的数量减少1，即 --count。
发现栅栏上剩余锁的数量count为2，说明栅栏没打开，则调用Condition的await方法，释放了ReentrantLock锁，进入沉睡队列等待，等待别人在栅栏打开的时候将它唤醒。

（2）我们再来看一下此时线程2调用CyclicBarrier的await方法的流程图：

线程2的执行流程跟上面的线程1是一样的，这里就不再多说了。
线程2调用CyclicBarrier的await方法之后，此时栅栏上剩余的锁数量count = 1，此时沉睡队列里面有两个线程（线程1、线程2）

（3）然后我们再继续看一下，线程3调用CyclicBarrier的await方法之后的流程图：

线程3调用CyclicBarrier的await方法之后，发现count减少为0了，此时栅栏打开了
然后查看barrierCommand栅栏打开之后的任务是否为null，如果不为null，则运行一下任务
然后调用nextGeneration方法，源码如下：

private void nextGeneration() {
    // 唤醒上面因为调用condition.await方法而进入沉睡队列的线程1、线程2
    trip.signalAll();
    // 重新设置栅栏上锁的数量count = parties
    count = parties;
    // 进入下一个批次了
    generation = new Generation();
}

调用trip.signalAll()即Condtion.signalAll方法唤醒，因为调用Condition.await方法而进入沉睡队列的线程1、线程2
然后重新设置一下栅栏上的锁数量count = parties；
然后生成下一个批次，generation = new Generation()

上面就是CyclicBarrier的await方法的核心源码流程了，CyclicBarrier的最核心的方法就是await方法了。

4  小结

其实就是整个可复用的计数器开关，比如最开始设置开关数量为3，到0的时候就打开开关。为了并发安全考虑，所以需要用到锁，同时为了实现阻塞唤醒的用到了Condtion。
每次调用await方法，先获取锁，然后计数器减少1，看看计数器是否为0，如果不是0，则释放锁，进入沉睡队列等待一下。如果是0了，则唤醒一下之前睡着的哥们，说开关打开了，我们一起通过吧。
为了实现复用的效果，这里会将计数器count进行复位，以及创建新的批次开启新一代，有理解不对的地方欢迎指正哈。