并发-4个同步辅助类（CountDownLatch、CyclicBarrier、Semphore、Phaser）

先来看下前2个

直译过来：

countDownLatch是一个同步的辅助类，允许一个或多个线程，等待其他一组线程完成操作，再继续执行。

CyclicBarrier是一个同步的辅助类，允许一组线程相互之间等待，达到一个共同点，再继续执行。

解读下：

首先是有个分组的概念，谁等谁,所以有2组角色，比如A组，B组。

countDownLatch:A组中的一个或者多个线程await(),B组里面的所有线程，B组里面的线程执行完就执行countdown();

线程数是预设固定的N,每个工作线程进来执行其耗时方法、完成时并计数器-1；直到0时唤醒去执行线程的方法；

按规则用，不要乱用,比如你非要在子线程执行await。

CyclicBarrier: 重点是B组里面的子线程相互等待，子线程执行 await();只有这一个方法。

区别：首先是概念上不一样；countdownlatch 需要2个方法；不可复用

实战代码：

public class CountDownLatchTest {
    static int playerCount = 3;
    static String[] nextArr={"大保健","回家WAR","回公司加班"};

    public static void main(String[] args){
        CountDownLatch countDownLatch  = new CountDownLatch(playerCount);
        for (int i = 0; i < playerCount; i++) {
            new Thread(new Player(i, countDownLatch)).start();
        }
        try {
            System.out.println("等待子线程执行完毕...");
            countDownLatch.await();
            System.out.println("我是主线程,收到--所有子线程已经执行完毕--继续执行主线程");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static class Player implements Runnable {
        int index ;
        CountDownLatch countDownLatch;
        public Player(int i, CountDownLatch cyclicBarrier) {
                this.index= i;
                this.countDownLatch = cyclicBarrier;
        }

        @Override
        public void run() {

            try {
                System.out.println("玩家："+index+"开跑...");
                //必须放在await 前面 否则无意思
                TimeUnit.SECONDS.sleep(6);
                System.out.println("玩家："+index+"跑完了10公里...开始等待其他人");

                countDownLatch.countDown();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //此处是否继续 看实际业务
            System.out.println("所有玩家都完成自己的任务，玩家:"+index+"接着去："+nextArr[new Random().nextInt(3)]);
        }
    }
}

public class CyclicBarrierTest {
    static int playerCount = 3;
    static String[] nextArr={"大保健","回家WAR","回公司加班"};

    public static void main(String[] args){
        CyclicBarrier cyclicBarrier  = new CyclicBarrier(playerCount, new Runnable() {
            @Override
            public void run() {
                //执行额外的工作
                System.out.println("终于等到他们都到齐了--把他们三个的成绩汇报下...");
            }
        });

        for (int i = 0; i < playerCount; i++) {
            new Thread(new Player(i, cyclicBarrier)).start();
        }

//        System.out.println("CyclicBarrier 再次重用------");
//        for (int i = 0; i < playerCount; i++) {
//            new Thread(new Player(i, cyclicBarrier)).start();
//        }
    }

    private static class Player implements Runnable {
        int index ;
        CyclicBarrier cyclicBarrier;
        public Player(int i, CyclicBarrier cyclicBarrier) {
                this.index= i;
                this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {

            try {
                System.out.println("玩家："+index+"开跑...");
                //必须放在await 前面 否则无意思
                TimeUnit.SECONDS.sleep(5);
                System.out.println("玩家："+index+"跑完了10公里...开始等待其他人");

                cyclicBarrier.await();

            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            //此处是否继续 看实际业务
            System.out.println("所有玩家都完成自己的任务，玩家:"+index+"接着去："+nextArr[new Random().nextInt(3)]);
        }
    }
}

网上有用这2个实现高并发测试的。