JUC之常用辅助类CyclicBarrier

一、CyclicBarrier介绍:

从字面上的意思可以知道，这个类的中文意思是“循环栅栏”。大概的意思就是一个可循环利用的屏障。
官网解释：

允许一组线程全部等待彼此达到共同屏障点的同步辅助。循环阻塞在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。屏障被称为循环 ，因为它可以在等待的线程被释放之后重新使用。
意思就是每个线程都得执行到等待点进行等待，直到所有线程都执行到等待点，才会继续往下执行。相当于日常开会，只有等每个参会的人都到之后才会开始会议。

它的作用就是会让所有线程都等待完成后才会继续下一步行动。

构造方法

public CyclicBarrier(int parties)
public CyclicBarrier(int parties, Runnable barrierAction)

解析：
parties 是参与线程的个数
第二个构造方法有一个 Runnable 参数，这个参数的意思是最后一个到达线程要做的任务

二、CyclicBarrier构造方法:

有两个构造方法，只有带Runnable参数的构造方法才会在所有线程都到达等待点之后执行Runnable里面的run方法。

//两个构造方法：
CyclicBarrier(int parties) {
    this(parties, null);
}

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

三、维护锁状态逻辑:

其底层使用ReentrantLock+Condition进行锁状态的维护;

1、维护锁状态
private final ReentrantLock lock = new ReentrantLock();
private final Condition trip = lock.newCondition();
2、线程组数 
private final int parties;
3、所有线程到达等待点后执行的Runnable
private final Runnable barrierCommand;
4、需要等待的线程数量    
private int count;
6、屏障点定义
private static class Generation {
    boolean broken = false;
}

具体看看其是如何实现等待逻辑的，线程等待需要调用await方法:

public int await() {
        return dowait(false, 0L);//调用的是dowait方法
 }
    
public int await(long timeout, TimeUnit unit){
    return dowait(true, unit.toNanos(timeout));//调用的是dowait方法
}

最终调用的是dowait方法:

private int dowait(boolean timed, long nanos){
        final ReentrantLock lock = this.lock;
        1、获取锁
        lock.lock();
        try {
            final Generation g = generation;
            if (g.broken)
                throw new BrokenBarrierException();
            2、如果线程中断，重置等待线程数量并且唤醒当前等待的线程 
            if (Thread.interrupted()) {
                breakBarrier();
                throw new InterruptedException();
            }
            3、等待线程数减1
            int index = --count;
            4、当等待线程数为0 时
            if (index == 0) {  // tripped
                boolean ranAction = false;
                try {
                    5、执行所有线程都到达等待点之后的Runnable 
                    final Runnable command = barrierCommand;
                    if (command != null)
                        command.run();
                    ranAction = true;
                    6、唤醒所有线程并生成下一代 
                    nextGeneration();
                    return 0;
                } finally {
                    if (!ranAction)
                        breakBarrier();
                }
            }
            7、如果等待线程数不为0
            for (;;) {
                try {
                    8、根据传入的参数来决定是定时等待还是非定时等待
                    if (!timed)
                        trip.await();
                    else if (nanos > 0L)
                        nanos = trip.awaitNanos(nanos);
                } catch (InterruptedException ie) {
                    9、线程中断之后唤醒所有线程并进入下一代
                    if (g == generation && ! g.broken) {
                        breakBarrier();
                        throw ie;
                    } else { 
                      Thread.currentThread().interrupt();
                    }
                }
                10、如果线程因为打翻屏障操作而被唤醒则抛出异常
                if (g.broken)
                    throw new BrokenBarrierException();
                11、如果线程因为换代操作而被唤醒则返回计数器的值
                if (g != generation)
                    return index;
                12、如果线程因为时间到了而被唤醒则打翻栅栏并抛出异常
                if (timed && nanos <= 0L) {
                    breakBarrier();
                    throw new TimeoutException();
                }
            }

        } finally {
            lock.unlock();
        }
    }

可以看到，是通过index字段控制线程等待的，当index不为0的时候，线程统一会进行阻塞，直到index为0的时候，才会唤醒所有线程，这时候所有线程才会继续往下执行。

四、CyclicBarrier的重复使用:

这个跟CountdownLatch不一样的是，CountdownLatch是一次性的，而CycliBarrier是可以重复使用的，只需调用一下reset方法。

public void reset() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        1、破坏当前的屏障点并唤醒所有线程 
        breakBarrier();   
        2、生成下一代
        nextGeneration(); 
    } finally {
        lock.unlock();
    }
}


private void breakBarrier() {
    generation.broken = true;
    将等待线程数量重置
    count = parties;
    唤醒所有线程 
    trip.signalAll();
}

private void nextGeneration() {
    唤醒所有线程
    trip.signalAll();
    将等待线程数量重置
    count = parties;
    generation = new Generation();
}

五、CountDownLatch与CyclicBarrier区别：

CountDownLatch与CyclicBarrier:
CountDownLatch是一个同步的辅助类，允许一个或多个线程，等待其他一组线程完成操作，被等待线程（例如主线程）再继续执行。
CyclicBarrier是一个同步的辅助类，允许一组线程相互之间等待，达到一个共同点，子线程再继续执行。CyclicBarrier可以被重用，比如有三个线程，执行逻辑到达同步点阻塞，到齐后被唤醒，又再次执行逻辑，到达下一个同步点，到齐后再被唤醒
区别:

CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次
CyclicBarrier还提供getNumberWaiting(可以获得CyclicBarrier阻塞的线程数量)、isBroken(用来知道阻塞的线程是否被中断)等方法。
CountDownLatch会阻塞主线程，CyclicBarrier不会阻塞主线程，只会阻塞子线程。

六、CyclicBarrier代码：

package com.fan.locktools;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("一起开会---");
        });
        for (int i = 1; i <= 7; i++) {
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+
                        "\t第"+temp+"个到了，等待开会---");
                try {
                    cyclicBarrier.await();//阻塞等待，等到了屏障点（人到齐）才执行最终任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

总结：CyclicBarrier是一个做加法的过程,和CountDownLatch是相反的。

CyclicBarrier 使用场景：

可以用于多线程计算数据，最后合并计算结果的场景。

代码二：

1、会议需要三个人
CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {
        @Override
        public void run()
            2、这是三个人都到齐之后会执行的代码
            System.out.println("三个人都已到达会议室")
        }
    });

3、定义三个线程，相当于三个参会的人
  for (int i = 0; i < 3; i++) {
      final int finalI = i;
      new Thread(new Runnable() {
          @Override
          public void run() {
              try {
                  4、模拟每人到会议室所需时间 
                  Thread.sleep((long) (Math.random()*5000));
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println("第"+Thread.currentThread().getName()+"个人到达会议室");
              try {
                  5、等待其他人到会议室 
                  cyclicBarrier.await();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              } catch (BrokenBarrierException e) {
                  e.printStackTrace();
              }
              System.out.println(Thread.currentThread().getName()+"开始开会");
          }
      }, String.valueOf(finalI)).start();
  }