CyclicBarrier简介

CyclicBarrier也是一种线程同步工具，用于多个线程之间的同步，也是适用于一个线程等待多个线程。和CountDownLatch相比，CyclicBarrier有多个改进：
1、CyclicBarrier可以循环利用
2、CyclicBarrier中的线程的同步更加严谨。CountDownLatch中的线程在countDown()后就会执行代码，而CyclicBarrier中的线程会一直阻塞，直到被同步的方法调用，所以说CyclicBarrier中的线程的同步程度更高。

CyclicBarrier示例

package juc;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class TestCyclicBarrier {

    public static void main(String[] args) {

        final CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {
            @Override
            public void run() {
                System.out.println("线程集合集合完毕");
            }
        });

        new Thread(){
            @Override
            public void run() {

                while (true){

                    try {

                        System.out.println("线程1开始执行");
                        Thread.sleep(5000);
                        System.out.println("线程1执行完毕");
                        barrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }

            }
        }.start();

        new Thread(){
            @Override
            public void run() {

                while (true){

                    try {

                        System.out.println("线程2开始执行");
                        Thread.sleep(5000);
                        System.out.println("线程2执行完毕");
                        barrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }

            }
        }.start();

    }
}

如上述例子所述，CyclicBarrier中分为两种线程：
1、同步执行的n个线程
2、等待n个线程完成后才开始执行的线程，我们叫他最后线程吧

CyclicBarrier源码详解

从上述结构图看，CyclicBarrier主要是利用ReentrantLock来保证同步的。

1、初始化

final CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {
          @Override
          public void run() {
              System.out.println("线程集合集合完毕");
          }
      });

public CyclicBarrier(int parties, Runnable barrierAction) {
    if (parties <= 0) throw new IllegalArgumentException();
    //对应的线程个数
    this.parties = parties;
    //当前未阻塞的线程个数
    this.count = parties;
    //执行的线程
    this.barrierCommand = barrierAction;
}

private static class Generation {
    boolean broken = false;
}

//独占锁
private final ReentrantLock lock = new ReentrantLock();
//因为CyclicBarrier是重复可利用的，一轮代表一代
private Generation generation = new Generation();
//当调用await后，会被阻塞。
private final Condition trip = lock.newCondition();

初始化代码调用的构造方法需要传入一个count和一个Runnable对象。
count对应着线程数量，Runnable对应着最后待同步的线程！

await()

在阅读原码前，朋友们先明白CyclicBarrier的一个机制：CyclicBarrier是可循环利用的，每个循环对应着一个年代，对应着CyclicBarrier就内置了一个Generation类，用来描述当前年代的状态。

private static class Generation {
    //n+1个线程中只要有一个被中断或者出现超时，就将broken设置为true
    boolean broken = false;
}

带着这个概念去阅读源码，思路就十分清晰了

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

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()) {
            //唤醒所有等待的线程，重置count，并将g.broken=true
            breakBarrier();
            //抛出异常
            throw new InterruptedException();
        }

        //await后调用后，count--
        int index = --count;
        if (index == 0) {  //count==0，说明所有线程都调用await()了，可以唤醒那n-1个线程了。
            //是否执行最后线程了
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                if (command != null)
                    //开始执行
                    command.run();
                //执行最后线程了
                ranAction = true;
                //释放所有等待在trip中condition queue中的线程
                nextGeneration();
                return 0;
            } finally {
                //如果执行ranAction失败，说明出现异常
                if (!ranAction)
                    //上述代码出现异常，执行breakBarrier
                    breakBarrier();
            }
        }


        //运行到这里的代码，都是n个线程中的n-1个线程
        for (;;) {
            try {
                //阻塞式调用
                if (!timed)
                    //阻塞将线程挂起到condition queue
                    trip.await();
                //调用的是await(timeout)，设置的有超时时间    
                else if (nanos > 0L)
                   //最多阻塞nanos时间将线程挂起到condition queue
                    nanos = trip.awaitNanos(nanos);
            } catch (InterruptedException ie) {
                //在等待的过程中，如果线程被中断，如果其他线程还未调用breakBarrier，那么当前线程就调用
                if (g == generation && ! g.broken) {
                    breakBarrier();
                    throw ie;
                } else {
                    //如果其他线程已经breakBarrier，就直接自我中断就ok了
                    Thread.currentThread().interrupt();
                }
            }

            //如果正常流程被打断，抛出BrokenBarrierException
            if (g.broken)
                throw new BrokenBarrierException();

            //如果正常的更新换代的话，返回index
            if (g != generation)
                return index;

            //如果await超时的话，也会breakBarrier，抛出TimeoutException
            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException();
            }
        }
    } finally {
        lock.unlock();
    }
}

private void breakBarrier() {
    //n+1个线程当中有线程被中断，或者await请求超时了，就将当前这个代打断，唤醒所有线程，各个线程自己单独处理这个异常
    
    //设置broken为true
    generation.broken = true;
    //重置count
    count = parties;
    // 唤醒等待在trip的condition queue中的全部线程
    trip.signalAll();
}

private void nextGeneration() {
	//当前这轮线程全部执行成功，重置年代，开始下一轮同步
    // 唤醒等待在trip的condition queue中的全部线程
    trip.signalAll();
    // count 重置为 parties
    count = parties;
    //generation也重新初始化
    generation = new Generation();
}

总结

1、CyclicBarrier的底层是通过一个ReentrantLock、一个int变量count、一个Condition、一个Generation来实现的。

流程：
1、首先初始化一个ReentranLock对象、将count变量赋值给parties，初始化一个Condition、初始化一个Generation,Generation中只有一个broken布尔两对应着当前的同步状态是否被破坏，将Runnable对象保存给barrierCommand。

2、当线程调用await()的时候。会先抢夺lock锁，然后将count--。如果count == 0，说明线程都已经执行完毕，可以开始执行barrierCommand了。并且通过SignalAll()来唤醒所有等待的线程，并且将Generation重新初始化，将count重新赋值为parties，开始下一轮的同步。

3、如果count！=0，说明还有其他线程未完成，就调用condition.await()方法，将线程挂起。

Tip

Generation.broken
当有线程被中断或者线程被挂起超时的时候，将generation的broken设置为true，代表同步被破坏了，会立即唤醒所有之前挂起的线程。
新来的线程在操作count--之前，会判断broken，如果broken=true，就会直接抛出异常！