本文已参与「新人创作礼」活动，一起开启掘金创作之路。

1. 简介

CyclicBarrier的字面意思是可循环使用的屏障，与CountDownLatch最明显的区别是CyclicBarrier是可循环的屏障，而CountDownLatch是只能使用一次的屏障。CyclicBarrier，回环栅栏，只有当一定数量的线程都到达才会继续往下执行。

CyclicBarrier与CountDownLatch异同：

• 都可以阻塞一组线程等待被唤醒
• CyclicBarrier是最后一个线程到达后会自动唤醒，而CountDownLatch需要显式调用countDown方法
• CyclicBarrier基于可重入锁和条件队列实现，CountDownLatch基于AQS实现
• CyclicBarrier可以重复使用，而CountDownLatch只能使用一次

2. 简单使用

下面是一个小案例，玩游戏的时候必须五个玩家同时加载完成才可以进入游戏。

package ImplCyclicBarrier;

import java.util.concurrent.*;

public class Demo01 {
    static int n = 5;
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(n, new Runnable() {
            @Override
            public void run() {
                System.out.println("准备开始");
            }
        });
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for(int i = 1; i <= n; i++){
            final int tmp = i;
            executorService.execute(new Player(tmp, cyclicBarrier));
        }

        executorService.shutdown();
    }
    static class Player implements Runnable{
        private String name;
        private CyclicBarrier cyclicBarrier;
        Player(int i, CyclicBarrier cyclicBarrier){
            name = "玩家" + i;
            this.cyclicBarrier = cyclicBarrier;
        }
        @Override
        public void run() {
            System.out.println(name + "进入游戏");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println(name + "加载完成");

        }
    }
}

结果如下：

3. 源码解析

3.1 成员变量

// 可重入锁ReentrantLock，条件队列基于ReentrantLock创建
private final ReentrantLock lock = new ReentrantLock();
// 一个条件队列
private final Condition trip = lock.newCondition();
// 代表需要等待多少个线程，我们在使用时一般使用count，只有初始化时才会使用parties，将parties赋值
// 给count，这也达到循环的目的
private final int parties;
// 代表最后一个线程到达后需要执行的任务
private final Runnable barrierCommand;
// 一个Generation内部类，当前代对象
private Generation generation = new Generation();
// 代表当前代还需要等待多少个线程
private int count;

内部类

// 这个是一个简简单单的内部类里面只有一个boolean变量，代表当前“代”是否被打破
private static class Generation {
            // 只有一个变量broken,表示当前代是否被打破，如果代被打破，则再来到这一代的线程，就会直接抛出BrokenException异常
    		// 在这一代的线程会被唤醒（加入AQS队列），然后抛出BrokenException异常
            boolean broken = false;
        }

3.2 构造方法

// parties表示需要等待的线程数量，barrierAction代表最后一个线程到达后需要执行的任务
public CyclicBarrier(int parties, Runnable barrierAction) {
    	// 小于等于0没有意义，直接抛出异常
        if (parties <= 0) throw new IllegalArgumentException();
    	// 代表需要等待的线程数量
        this.parties = parties;
    	// 代表当前代需要等待的线程数量
        this.count = parties;
    	// 最后一个线程到达后需要执行的任务
        this.barrierCommand = barrierAction;
    }
// parties表示需要等待的线程数量，这个构造方法最后一个线程到达后不需要执行额外的任务
public CyclicBarrier(int parties) {
    	// 调用另一个构造方法
        this(parties, null);
    }

3.3 成员方法

3.3.1 await方法

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

3.3.2 dowait方法

// timed：当前线程是否执行了超时时长
// nanos：单位为纳秒，表示等待时长
private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        // 获取ReentrantLock锁
        final ReentrantLock lock = this.lock;
        // 加锁
        lock.lock();
        try {
            // 当前代对象
            final Generation g = generation;
			// 如果当前代被打破，则调用await方法之后进入dowait方法，抛出BrokenBarrierException异常
            if (g.broken)
                throw new BrokenBarrierException();
			// 中断检查
            if (Thread.interrupted()) {
                // 设置broken为true，然后唤醒（加入AQS队列）trip中的对象
                breakBarrier();
                throw new InterruptedException();
            }
			// 获取count-1的值
            int index = --count;
            // 如果count-1 == 0，要看看Runnable是否为空（最后一个线程到达后是否有任务要执行）
            if (index == 0) {  // tripped
                boolean ranAction = false;
                try {
                    final Runnable command = barrierCommand;
                    if (command != null)
                        command.run();
                    ranAction = true;
                    // 最后一个线程走这里，调用nextGeneration方法，开启下一代
                    nextGeneration();
                    return 0;
                } finally {
                    // 如果command.run()抛出异常，会执行breakBarrier方法
                    if (!ranAction)
                        breakBarrier();
                }
            }
			// 只有不是最后一个的线程才可以执行到这里
            // 自旋，一直到条件满足：当前代被打破，线程被中断，等待超时
            // loop until tripped, broken, interrupted, or timed out
            for (;;) {
                try {
                    // 说明不指定超时时间，调用await方法，之后await又会走到这里，自旋
                    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();
        }
    }

3.3.3 breakBarrier方法

// 打破屏障
private void breakBarrier() {
    	// 设置当前代被打破
        generation.broken = true;
    	// 重置count的值
        count = parties;
    	// 将当前代所有线程假如AQS队列
        trip.signalAll();
    }

3.3.4 nextGeneration方法

// 当最后一个线程到达，dowait方法内部会调用这个方法开启下一代
private void nextGeneration() {
        // signal completion of last generation
    	// 将当前代所有对象加入AQS队列
        trip.signalAll();
        // set up next generation
    	// 重置count的值
        count = parties;
    	// 新new一个Generation对象
        generation = new Generation();
    }

4. 总结

• CyclicBarrier在调用await后，在最后一个线程到达前会一直阻塞在await处，只有当最后一个线程到达后，才会将当前代所有线程加入AQS队列
• CyclicBarrier基于ReentrantLock和Condition实现，并没有使用AQS。