关于 CycleBarrier

Java JUC 包中提供类似的工具，可以设置一个简单的集合点，等所有成员到齐了之后，再执行下一步操作。CycleBarrier 它就相当于是一个栅栏，所有线程在到达栅栏后都需要等待其他线程，等所有线程都到达后，再一起通过。

CyclicBarrier 可以有不止一个栅栏，因为它的栅栏（Barrier）可以重复使用（Cyclic）。

CycleBarrier 特别适用于并行迭代计算，每个线程负责一部分计算，然后在栅栏处等待其他线程完成，所有线程到齐后，交换数据和计算结果，再进行下一次迭代。

初步理解

CyclicBarrier 有一个 parties 成员变量，表示参与的线程的个数，下面来看一个例子，我们通过这个例子来理解下 Cycle 的含义：

public class Demo1 {
 
    public static void main(String[] args) {
        // 初始化一个 CyclicBarrier，大小为 5，当 5 个线程满足条件之后，就执行一次：执行完毕！
        CyclicBarrier cyclicBarrier = new CyclicBarrier( 5, () -> {
            System.out.println("执行完毕！");
        });
 
        // 为了测试是否能循环，这里循环设置为 20，预期的结果应该是会执行 4 次：执行完毕！
        for (int i=0; i<20; i++) {
            int temp = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + ", 执行到：" + temp );
                try{
                    cyclicBarrier.await();  // 等待其他线程到齐，到齐了之后就会执行一次
                } catch (BrokenBarrierException | InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

程序输出

由于多线程输出，我是多刷了几遍（也不知道刷了多少遍了）就会出现下面的执行结果，这里就可以看出来效果了，这里有 20个线程，5 个线程为一组（如果是按照源码上面来说，就是 5 个线程 parties 为一代 generation ），可以满足我们的预期。

每次参与的线程数为 5，然后当 5个线程都执行完毕之后，再进入下一代的计算，看到这里应该还是比较容易理解的。

源码探究

看到这里了，我们就去看下源码是什么情况吧。

成员变量

首先，我们看下 CycleBarrier 的成员变量：

//同步操作锁
private final ReentrantLock lock = new ReentrantLock();
//线程拦截器
private final Condition trip = lock.newCondition();
//每次拦截的线程数
private final int parties;
//换代前执行的任务
private final Runnable barrierCommand;
//表示栅栏的当前代
private Generation generation = new Generation();
//计数器
private int count;
 
//静态内部类Generation
private static class Generation {
    Generation() {}                 // 防止访问构造函数创建
    boolean broken;                 // 初始化为 false
}

这里说明下:

• trip 是一个 condition，就是用来阻塞与唤醒线程使用的。
• 两个 int 类型的变量 parties 与 count，在初始化 CycleBarrier 的时候，两个值的大小是一样的，之后随着线程的 await 方法的调用而 -1，直到减到 0 ，就将所有的线程全部唤醒。
• 内部静态变量 Generation，表示当前栅栏的代，上面的例子中，5个线程就为一代，执行完了，就进行下一代。
• barrierCommond，表示换代前执行的任务，当 count 减为 0 时表示本次结束。在转到下一局游戏之前，将所有的线程唤醒，在唤醒之前可以通过指定的 barrierCommond 来执行自己的任务。

构造器

接着，我们看下构造器相关的源码，这里就可以看到 count 与 parties 的初始化的时候就是一致的

//构造器，这里就是我们上面那个例子使用的构造器
public CyclicBarrier(int parties, Runnable barrierAction) {
  if (parties <= 0) throw new IllegalArgumentException();
  this.parties = parties;
  this.count = parties;
  this.barrierCommand = barrierAction;
}
 
// 构造器，只传入一个 parties 的大小，不进行自定义任务
public CyclicBarrier(int parties) {
  this(parties, null);
}

await() 方法

这里我们看下 await() 方法，在上面的例子中，是使用 await() 方法等待其他线程到齐，再去执行后面的操作

// 非定时等待
public int await() throws InterruptedException, BrokenBarrierException {
  try {
    return dowait(false, 0L);
  } catch (TimeoutException toe) {
    throw new Error(toe);
  }
}
 
// 定时等待
public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException {
  return dowait(true, unit.toNanos(timeout));
}

看源码之后，发现 await() 方法最后都是调用 dowait() 方法，我们就直接看下 核心的 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()) {
            // 如果中断了，就会执行下面三件事
            // 1. 将 generation 的 broken 标记设置为 true
            // 2. 重置 count 值
            // 3. 唤醒当前拦截的线程
            breakBarrier();
            throw new InterruptedException();
        }
 
        int index = --count;    // 每次都将计数器的值减 1
        if (index == 0) {          // 计数器的值减为0，就会唤醒所有线程并转换到下一代
            Runnable command = barrierCommand;
            if (command != null) {       // 如果存在自定义的任务，这里就会做判断，在唤醒所有线程之前执行
                try {
                    command.run();
                } catch (Throwable ex) {
                    breakBarrier();
                    throw ex;
                }
            }
            nextGeneration();    // 唤醒所有线程，并转到下一代
            return 0;
        }
 
        //官方注释： loop until tripped, broken, interrupted, or timed out
        //这里循环是：如果计数器不为0则执行此循环
        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 {
                     //若在捕获中断异常前已经完成在栅栏上的等待, 则直接调用中断操作
                    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()

后面，我们看下刚刚上面提到过的切换代 nextGeneration()， 打破栅栏方法 breakBarrier()

//切换栅栏到下一代
private void nextGeneration() {
  //唤醒条件队列所有线程
  trip.signalAll();
  //设置计数器的值为需要拦截的线程数
  count = parties;
  //重新设置栅栏代次
  generation = new Generation();
}
 
//打破当前栅栏
private void breakBarrier() {
  //将当前栅栏状态设置为打破
  generation.broken = true;
  //设置计数器的值为需要拦截的线程数
  count = parties;
  //唤醒所有线程
  trip.signalAll();
}

reset()

最后，我们看下怎么重置，这里其实就是调用了上面说的 切换代 nextGeneration() 与 breakBarrier() 方法

public void reset() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        breakBarrier();   // break the current generation
        nextGeneration(); // start a new generation
    } finally {
        lock.unlock();
    }
}

回顾

最后看一个例子回顾下

public class Demo {
 
    static class Tourist extends Thread {
        CyclicBarrier cyclicBarrier;
 
        public Tourist(CyclicBarrier cyclicBarrier){
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            try {
                // 模拟点先各自独立运行
                Thread.sleep( (int) (Math.random() * 1000) );
                // 集合点 A
                cyclicBarrier.await();
                System.out.println(this.getName() + "，到达集合点 A " + System.currentTimeMillis() );
 
                // 集合后模拟再各自独立运行
                Thread.sleep( (int) (Math.random() * 1000));
                // 集合点 B
                cyclicBarrier.await();
                System.out.println(this.getName() + "，到达集合点 B " + System.currentTimeMillis() );
 
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
 
    public static void main(String[] args) {
        // 定义出多个 线程
        int num = 3;
        Tourist[] tourist = new Tourist[num];
 
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("集合完毕： " + System.currentTimeMillis() + " 执行的线程为： " + Thread.currentThread().getName());
        });
 
        for (int i = 0; i< num; i++){
            tourist[i] = new Tourist(barrier);
            tourist[i].start();
        }
    }
}