Java并发之CyclicBarrier（同步屏障）

参考文章：https://blog.csdn.net/tongdanping/article/details/79589253

CyclicBarrier（同步屏障）

让一组线程到达一个屏障（或者同步点）时被阻塞，知道所有线程到达同步屏障后，同步屏障开门，所有线程继续执行。

同步屏障的使用：同步屏障有两种使用方式，从CyclicBarrier的构造方法个可以看出来

 //构造方法1
public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }

//构造方法2
public CyclicBarrier(int parties) {
     this(parties, null);
}

构造器方法1：
传入要阻塞的线程的数量parties和一个Runnable的对象，这个对象的作用是用于处理以下复杂的业务场景情形：当需要在第一个线程到达屏障前，前处理一个任务，这个任务可以写在barrierAction中。

构造器方法2：
runnable对象为null说明只需要简单的等待其他线程到达同步屏障即可。

接下来举例说明两种同步屏障的使用

构造方法2：
（1）创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量；

（2）在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；

public class CyclicBarrierTest {
     //创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量；
    static CyclicBarrier cb = new CyclicBarrier(2);
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                     // 在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
                    cb.await();            
                    System.out.println(1);
                }
                catch(Exception e){
                    System.out.println("thread 1");
                }
            }
        }).start();
        try{
         //在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
            cb.await();
            System.out.println(2);
        }
        catch(Exception e){
            System.out.println("main");
        }
    }

}

输出结果：

输出结果不一定为1 2，也有可能为2 1

构造器1：

（1）创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量，和barrierAction对象；

（2）写一个实现Runnable接口的class，用于实现第一个线程到达同步屏障前的业务逻辑；

（3）在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；

public class CyclicBarrierTest {
     //创建一个CyclicBarrier对象，传入要阻塞在同步屏障的线程数量，和barrierAction对象；
    static CyclicBarrier cb = new CyclicBarrier(2,new DoSomeThing());
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                     // 在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
                    cb.await();            
                    System.out.println(1);
                }
                catch(Exception e){
                    System.out.println("thread 1");
                }
            }
        }).start();
        try{
            // 在每个要阻塞在同步屏障的子线程中调用cb.await( )方法；
            cb.await();
            System.out.println(2);
        }
        catch(Exception e){
            System.out.println("main");
        }
    }

  //写一个实现Runnable接口的class，用于实现第一个线程到达同步屏障前的业务逻辑；
    public static class DoSomeThing implements Runnable{  
        @Override
        public void run(){
            System.out.println("happen-before CyclicBarrier");
        }
    }
}

输出结果：

个人觉得 1 和 2的顺序是不确定的，但“happen-before CyclicBarrier”一定是最先输出的

*注意：

因为cb.await( )方法会抛出InterruptedException和BrokenBarrierException异常，因此在子线程中要使用try-catch方法来捕捉这两种异常；

CyclicBarrier中的线程计数器可以使用reset（）方法重置；

在所有线程到达同步屏障后，并不是所有线程“同时”开始执行，而是使各个线程的启动时间降到最低；

使用场景：
需要多线程的计算结果最后对这些结果进行合并的场景；

并发工具类CountDwonLatch与CyclicBarrier的区别

1、CountDwonLatch阻塞一个线程，CyclicBarrier阻塞多个线程；

2、CountDwonLatch的计数器在构造对象时确定了就不能更改，但是CyclicBarrier可以使用reset（）方法重置计数器；

3、CyclicBarrier的功能更加丰富，比如int getWaitingNumber（）方法返回被阻塞在同步屏障的线程数，boolean isBroken（）方法返回是否有阻塞的线程被中断