一文搞懂四种同步工具类

https://mp.weixin.qq.com/s/j2EtFf_hOJm9L_y2jje7uQ

CountDownLatch

解释：

CountDownLatch相当于一个门闩，门闩上挂了N把锁。只有N把锁都解开的话，门才会打开。怎么理解呢？我举一个赛跑比赛的例子，赛跑比赛中必须等待所有选手都准备好了，裁判才能开发令枪。选手才可以开始跑。

CountDownLatch当中主要有两个方法，一个是await()会挂上锁阻塞当前线程，相当于裁判站在起始点等待，等待各位选手准备就绪，一个是countDown方法用于解锁，相当于选手准备好了之后调用countDown方法告诉裁判自己准备就绪，当所有人都准备好了之后裁判开发令枪。

代码：

public class TestCountDownLatch {
    public static void main(String[] args) {
        // 需要等待两个线程，所以传入参数为2
        CountDownLatch latch = new CountDownLatch(2);
        // 该线程运行1秒
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("1号选手准备就绪！用时1秒！");
                latch.countDown();
            }
        }).start();
        
        // 该线程运行3秒
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("2号选手准备就绪！用时3秒！");
                latch.countDown();
            }
        }).start();
        
        try {
            System.out.println("请1号选手和2号选手各就各位！");
            // 主线程在此等待两个线程执行完毕之后继续执行
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 两个线程执行完毕后，主线程恢复运行
        System.out.println("裁判发枪，1号选手和2号选手开跑！");
    }
}

运行结果：

请1号选手和2号选手各就各位！
1号选手准备就绪！用时1秒！
2号选手准备就绪！用时3秒！
裁判发枪，1号选手和2号选手开跑！

裁判就会在选手还未准备就绪的时候开发令枪，这就乱套了。
其实CountDownLatch一个最简单的用处就是计算多线程执行完毕时的时间。像刚才的例子当中两个线程并行执行了共花费了3秒钟。

CyclicBarrier

解释：

CyclicBarrier就像一个栅栏，将各个线程拦住。Cyclic是循环的英文，表明该工具可以进行循环使用。CyclicBarrier(N)的构造参数表明该一共有几个线程需要互相等待。它相当于N个选手约定进行多次比赛，每次比赛完都要在起跑点互相等待。

读者可能会马上疑惑这不是和CountDownLatch一样吗？不一样。因为CountDownLatch是裁判等待选手，是调用await()方法的线程，等待调用countDown()方法的各个线程。而CyclicBarrier是选手等待选手，是调用await()方法的线程互相等待，等待其他线程都运行好之后，再开始下一轮运行。

我们举一个例子，两个选手进行比赛，一共进行三轮比赛。

代码：

package thread;

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

public class TestCyclicBarrier {
    // 1号选手跑的轮数
    public static int countA = 1;
    // 2号选手跑的轮数
    public static int countB = 1;

    public static void main(String[] args) {
        // 填入2,代表2个线程互相等待
        CyclicBarrier barrier = new CyclicBarrier(2);

        new Thread(() -> {
            // 一共跑三轮
            for (int i = 0; i < 3; i++) {
                System.out.println("1号选手开始跑！当前第" + countA++ + "轮比赛！");
                // 1号选手跑得慢，每次跑三秒
                try {
                    Thread.sleep(3000);
                    System.out.println("1号选手抵达终点！");
                    // 调用等待方法，在此等待其他选手
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(() -> {
            // 一共等待三轮
            for (int i = 0; i < 3; i++) {
                System.out.println("2号选手开始跑！当前第" + countB++ + "轮比赛！");
                try {
                    Thread.sleep(1000);
                    System.out.println("2号选手抵达终点！");
                    // 调用等待方法，在此等待其他选手
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

}

运行结果:

1号选手开始跑！当前第1轮比赛！
2号选手开始跑！当前第1轮比赛！
2号选手抵达终点！
1号选手抵达终点！
1号选手开始跑！当前第2轮比赛！
2号选手开始跑！当前第2轮比赛！
2号选手抵达终点！
1号选手抵达终点！
1号选手开始跑！当前第3轮比赛！
2号选手开始跑！当前第3轮比赛！
2号选手抵达终点！
1号选手抵达终点！

每轮比赛1号选手和2号选手都会回到起跑线互相等待，再开启下一轮比赛。

 CyclicBarrier是java提供的同步辅助类。

一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)，才得以继续执行。阻塞子线程，当阻塞数量到达定义的参与线程数后，才可继续向下执行。

public class BarrierMain {

    public static void main(String[] args) {
        ThreadPoolExecutor executor=new ThreadPoolExecutor(5,5,1, TimeUnit.SECONDS
                ,new ArrayBlockingQueue<Runnable>(10)){
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                super.afterExecute(r, t);
            }
        };
        CyclicBarrier cyclicBarrier=new CyclicBarrier(3, new Runnable() {
            @Override
            public void run() {
                System.out.println("=====当前阶段已完成");
            }
        });
        executor.submit(new BarrierDemo(cyclicBarrier));
        executor.submit(new BarrierDemo(cyclicBarrier));
        executor.submit(new BarrierDemo(cyclicBarrier));
        System.out.println("====主线程执行完毕");
        executor.shutdown();
    }
}

public class BarrierDemo implements Runnable {

    private final CyclicBarrier barrier;


    public BarrierDemo(CyclicBarrier barrier) {
        this.barrier = barrier;
    }

    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName()+"到达现场");
            Thread.sleep(5000);
            //阻塞子线程
            barrier.await();
            //继续执行
            System.out.println(Thread.currentThread().getName()+"开始表演");
            Thread.sleep(5000);
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

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

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