多线程CountDownLatch、CyclicBarrier、Semaphore同步工具类

Java为我们提供了三个同步工具类：
CountDownLatch(闭锁)
CyclicBarrier(栅栏)
Semaphore(信号量)
这几个工具类其实说白了就是为了能够更好控制线程之间的通讯问题~
一、CountDownLatch
1.1CountDownLatch简介
A synchronization aid that allows one or more threads to wait until a set of operations
being performed in other threads completes.
简单来说：CountDownLatch是一个同步的辅助类，允许一个或多个线程一直等待，直到其它线程完成它们的操作。它常用的API其实就两个: await() 和countDown()
使用说明：
count初始化CountDownLatch，然后需要等待的线程调用await方法。await方法会一直受阻塞直到count=0。而其它线程完成自己的操作后，调用countDown() 使计数器count减1。当count减到0时，所有在等待的线程均会被释放,说白了就是通过count变量来控制等待，如果count值为0了(其他线程的任务都完成了)，那就可以继续执行。
例子：其他员工都走了自己才能走

    public static void main(String[] args) {
        final CountDownLatch countDownLatch = new CountDownLatch(5);
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("其他的员工都走光了，自己可以走了");
            }
        }).start();

        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    countDownLatch.countDown();
                    System.out.println("员工xxxx下班了");
                }
            }).start();
        }
    }

效果：

二、CyclicBarrier
2.1CyclicBarrier简介
A synchronization aid that allows a set of threads to all wait for each other to reach a
common barrier point. CyclicBarriers are useful in programs involving a fixed sized
party of threads that must occasionally wait for each other. The barrier is called cyclic
because it can be re-used after the waiting threads are released.
简单来说：CyclicBarrier允许一组线程互相等待，直到到达某个公共屏障点。叫做cyclic是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用(对比于CountDownLatch是不能重用的)
使用说明：
CountDownLatch注重的是等待其他线程完成，CyclicBarrier注重的是：当线程到达某个状态后，暂停下来等待其他线程，所有线程均到达以后，继续执行。
2.2CyclicBarrier例子
例子：两人一起吃饭回家流程

 public static void main(String[] args) {
        final CyclicBarrier CyclicBarrier = new CyclicBarrier(2);
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    String name = Thread.currentThread().getName();
                    if (name.equals("Thread-0")) {
                        name = "我";
                    } else {
                        name = "女朋友";
                    }
                    System.out.println(name + "到了体育⻄");
                    try {
                        // 两个人都要到体育⻄才能发朋友圈
                        CyclicBarrier.await();
                        // 两人到达了体育⻄，看⻅了对方发了一条朋友圈：
                        System.out.println("跟" + name + "去夜上海吃东⻄~");
                        // 两个人都要到要回到家，才能洗澡
                        CyclicBarrier.await();
                        System.out.println(name + "洗澡");
                        // 洗澡完之后一起聊天
                        CyclicBarrier.await();
                        System.out.println("一起聊天");
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

效果：

三、Semaphore
3.1Semaphore简介
Semaphore(信号量)实际上就是可以控制同时访问的线程个数，它维护了一组"许可证"。
当调用acquire() 方法时，会消费一个许可证。如果没有许可证了，会阻塞起来
当调用release() 方法时，会添加一个许可证。
这些"许可证"的个数其实就是一个count变量罢了~
3.2Semaphore例子
商场1折大甩卖，小店一次只能容纳10个顾客挑选购买，超过10个就需要排队啦~~~

    public static void main(String[] args) {
        // 假设有50个同时来到⻔口
        int nums = 50;
        // 店只能容纳10个人同时挑选
        final Semaphore semaphore = new Semaphore(10);
        for (int i = 0; i < nums; i++) {
            final int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 有"号"的才能进店挑选购买
                        semaphore.acquire();
                        System.out.println("顾客" + finalI + "在挑选商品，购买...");
                        // 假设挑选了xx⻓时间，购买了
                        Thread.sleep(1000);
                        // 归还一个许可，后边的就可以进来购买了
                        System.out.println("顾客" + finalI + "购买完毕了...");
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

效果图：