CyclicBarrier源码-JUC线程同步工具3

CyclicBarrier源码-JUC线程同步工具3

这是线程同步的第三个工具类，跟前文CountDownLatch 如果理解不深入，会觉得他们很相似，觉得都是一个主线程在等待其它子线程完成自己的任务，主线程运行。本文会介绍它们两个的区别，以及内部实现。

何为CyclicBarrier
CyclicBarrier 是一个让一系列线程集合互相等待直到一个公共屏障点(barrier point)的同步辅助工具。这个屏障被称为循环屏障，是因为它可以在等待线程释放后被重用。

说的依然比较抽象：简单来说，A线程在等待另外几个线程完成某个工作之后再A在继续执行，然后A完成任务之后，A可以在在等待这几个线程去完成自己的任务，A在执行，还不是很懂？？？

举个例子
三个人进行2个地方的游玩，
A，B，C 都到景点的集合点1，然后去第一个景点，三个人开始游玩。
A，B，C 都到景点的集合点2，然后去第二个景点，三个人开始游玩，结束。

内部其实就是一个条件锁，线程run可以调用多次await
每个线程调用await都会先lock.lock 之后再判断构造方传入的参数count都是减小到0 否则条件锁condition.await
condition.await释放了lock.lock的锁 ，其它线程可以在调用await方法 如此一来等到count为0 构造方法的第二个参数runable就得以执行
执行完毕之后在进行一次generation的创建 同事唤醒所有的线程，然后又了新的generation之后线程有被唤醒了 线程的run方法就可以进行第二次调用await了如此

Semaphore 内部是直接AQS accquire都会对state-1 减到0 就阻塞
CountDownLatch 内部是直接AQS countDown 会对state-1 减到0 调用await的就【不阻塞了】

其实这里可以看出它跟CountDownLatch已经有区别了，CountDownLatch只能是完成上面例子中的第一个景点，然后就结束了。
如果把集合点作为一个屏障的话，CountDownLatch就只能是一个屏障，CyclicBarrier是可以重置屏障，在继续等所有人到，在做另外一件事情。

代码使用

public static void main(String[] args) {
	CyclicBarrier cb = new CyclicBarrier(3,new Runnable() {
		@Override
		public void run() {
			System.out.println("导游：出发去景点------");
		}
	});
	
	new Person(cb,"张三").start();
	new Person(cb,"李四").start();
	new Person(cb,"王五").start();	
}

static class Person extends Thread{
	private Random random = new Random();
	private CyclicBarrier cyclicBarrier;
	private String name;
	public Person(CyclicBarrier cyclicBarrier,String name){
		this.cyclicBarrier = cyclicBarrier;
		this.name = name;
	}
	
	@Override
	public void run() {
		
		try {
			Thread.sleep(random.nextInt(1000));//AAAA 不加这一行  会导致所有线程同时进入下面的打印，await没来及count-- 入队、进入条件队列释放锁等导致打印出来3
			System.out.println(Thread.currentThread().getName()+"到达【集合点1】等待其他"+(cyclicBarrier.getParties()-cyclicBarrier.getNumberWaiting())+"个人");
			cyclicBarrier.await();
			System.out.println(Thread.currentThread().getName()+"在景区【集合点1】游玩...");
			
			
			Thread.sleep(2000);
			System.out.println(Thread.currentThread().getName()+"到达【集合点2】等待其他"+(cyclicBarrier.getParties()-cyclicBarrier.getNumberWaiting())+"个人");
			cyclicBarrier.await();
			System.out.println(Thread.currentThread().getName()+"在景区【集合点2】游玩....");
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			e.printStackTrace();
		}
	}
}

运行结果：
Thread-0到达【集合点1】等待其他3个人
Thread-2到达【集合点1】等待其他2个人
Thread-1到达【集合点1】等待其他1个人
导游：出发去景点------
Thread-1在景区【集合点1】游玩…
Thread-0在景区【集合点1】游玩…
Thread-2在景区【集合点1】游玩…
Thread-1到达【集合点2】等待其他3个人
Thread-0到达【集合点2】等待其他2个人
Thread-2到达【集合点2】等待其他1个人
导游：出发去景点------
Thread-2在景区【集合点2】游玩…
Thread-1在景区【集合点2】游玩…
Thread-0在景区【集合点2】游玩…

里边有一行代码//AAA的如果去掉了打印结果将变成
Thread-0到达【集合点1】等待其他3个人
Thread-2到达【集合点1】等待其他3个人
Thread-1到达【集合点1】等待其他3个人
导游：出发去景点------
Thread-1在景区【集合点1】游玩…
Thread-0在景区【集合点1】游玩…
Thread-2在景区【集合点1】游玩…
Thread-1到达【集合点2】等待其他3个人
Thread-0到达【集合点2】等待其他2个人
Thread-2到达【集合点2】等待其他1个人
导游：出发去景点------
Thread-2在景区【集合点2】游玩…
Thread-1在景区【集合点2】游玩…
Thread-0在景区【集合点2】游玩…

这其中很奥妙！！！

代码很简单，程序的运行结果也跟我们的举例类似。我们顺着使用翻看源码。

重要的属性

private static class Generation {
	boolean broken = false;
}
private final ReentrantLock lock = new ReentrantLock();
private final Condition trip = lock.newCondition();//只有一个线程每调用await，那么当前线程就条件锁阻塞
private final int parties;//构造方法的第一个参数，参与线程数 不可变
private final Runnable barrierCommand;//构造方法第二个参数，在执行每个线程业务逻辑之前执行的命令。
private Generation generation = new Generation();//可以理解一个屏障点，多次new赋值就是重置屏障点
private int count;//调用await的线程数=parties--

比较出乎我意料的事，没有看到AQS相关静态内部抽象类，但是出现了ReentrantLock和condition，好在在我们的掌控范围内不熟悉的强烈推荐看看我之前的两篇博文ReentrantLock源码分析和条件锁，跟以往一样，跟锁有关的我们一代而过，因为之前详细分析过。

构造方法

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

构造方法是重载这里使用了2个参数的，其中的Runnable barrierAction
是所有线程都到达屏障（集合点之后）先执行 的，它执行完毕之后再是的调用await的线程执行业务逻辑。用我们上面的例子来说明的话就是–导游说的那个逻辑 所有人到期了，导游说出发，然后所有人去景点了。

其实这整个的CyclicBarrier没几个方法 我们在看最核心的方法
CountDownLatch 是1个调用await 其他的线程调用countDown，而这里是所有线程都调用await方法。

await()方法

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

dowait(false,0L)方法

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****************
        int index = --count;
        if (index == 0) {  // tripped  parties个线程都已经调用await（）
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                if (command != null)
                    command.run();
                ranAction = true;
                nextGeneration();
                return 0;
            } finally {
                if (!ranAction)
                    breakBarrier();
            }
        }
        //核心代码2 parties个线程中还有每调用await的
        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
private void nextGeneration() {
    // signal completion of last generation
    trip.signalAll();
    // set up next generation
    count = parties;
    generation = new Generation();
}

代码看起来有点长，但是只看核心代码的话是非常简单的，核心代码已标注了。
await(false,0L)是使用ReentrantLock来保护的如下几个操作：

count–
if (count == 0)
breakBarrier()
这几个操作都是要一个线程来完成，其它不能在执行的。

核心逻辑如下：

count == 0

即parties（CyclicBarrier构造方法的第一个参数）个线程都调用了await方法此时线程都是在条件队列中，在任何线程被唤醒之前执行barrierCommand，例子中导游，然后在执行nextGeneration()-- 唤醒条件队列中的线程，重新给count=parties，新创建一个屏障，即可重置栅栏。

count>0

即parties个线程中还有没有调用await的线程，执行trip.await(); 即当前线程进入到条件队列中挂起。

正向的逻辑就是如上所说的，在parties线程中，任意一个线程没有调用await方法，那么所有线程都会进入条件队列挂起，知道parties都调用了await方法，先执行构造方法中的barrierCommand，然后在唤醒条件队列中的所有线程，执行自己的业务逻辑，执行外币重置栅栏即generation = new Generation()；

breakBarrier()方法

private void breakBarrier() {
    generation.broken = true;
    count = parties;
    trip.signalAll();
}

还是以我们文章前部分举例子：
A，B，C三个人，A和C都已经到了集合点了，但是B死活没到（线程中断、异常、或者A和B等待超时）,这个时候就应该不等B了，A和C就应该被唤醒。实际上程序也是这样如次的。
也就是从trip.await()之后的代码又得到了执行，再次判断是否generation.broken或者timed&& nanos<0 抛出BrokenBarrierException或者TimeOutException，释放锁。

总结：

CyclicBarrier和CountDownLatch都是线程同步的工具

CountDownLatch 完成几个线程完成任务之后调用countDown(1)方法，主线程调用await方法被唤醒得以执行。

CyclicBarrier 是parties个线程都调用await()方法之后（只要其中任意一个没有调用都在条件队列挂起），如果构造方法的第二个参数barrierCommand不为空的话，它会在所有线程被唤醒之前先执行，然后所有线程被唤醒开始执行自己的业务逻辑，重置屏障。每个线程再次调用await，等所有线程都调用了await在执行第二个屏障点之后的任务。

CyclicBarrier跟Semaphore和CountDownLatch都是线程同步工具，但底层实现与后两者差别很大，它底层是ReentrantLock和condition 来控制线程同步的，不像其他两个维护一个抽象静态内部类AQS。