7 JUC三大辅助类

JUC中提供了三种常用的辅助类，通过这些辅助类可以很好的解决线程数量过多时Lock锁的频繁操作。但三种辅助类为：

CountDounLatch：减少计算
CyclicBarrier：循环栅栏
Semaphore：信号灯

7.1 减少计数CountDownLatch

CountDownLatch 类可以设置一个计数器，然后通过 countDown 方法来进行减 1 的操作，使用 await 方法等待计数器不大于 0，然后继续执行 await 方法之后的语句。

CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞
其他线程调用countDown方法会将计数器减1（调用countDown方法的线程不会阻塞）
当技术器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行

场景：6个同学陆续离开教室后同学才可以关门。

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 定义一个数值为6的计数器
        CountDownLatch downLatch = new CountDownLatch(6);

        // 创建6个同学
        for (int i = 1; i <= 6; i++) {
            new Thread((()->{
                try {
                    if (!Thread.currentThread().getName().equals("同学6")){
                        TimeUnit.SECONDS.sleep(6);
                    }
                    System.out.println(Thread.currentThread().getName()+"离开了");
                    // 计数器减1不会阻塞
                    downLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }),"同学"+i).start();
        }

        // 主线程await休息
        System.out.println("主线程睡觉");
        downLatch.await();
        // 全部离开后，自动唤醒主线程
        System.out.println("全部离开了，现在的计数器为"+downLatch.getCount());
    }
}

7.2 循环栅栏CyclicBarrier

CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加 1 操作

场景：集齐7颗龙珠就可以召唤神龙

public class CyclicBarrierDemo {
    // 定义召唤神龙需要的龙珠数
    private static final int NUMBER = 7;
    public static void main(String[] args) {
        // 定义循环栅栏
        CyclicBarrier cyclicBarrier = new CyclicBarrier(NUMBER, () ->
            System.out.println("集齐"+NUMBER+"颗龙珠，现在准备召唤神龙！！！")
        );

        // 定义七个线程分别去收集龙珠
        for (int i = 1; i <= 7; i++) {
            new Thread(()->{
                try {
                    if (Thread.currentThread().getName().equals("龙珠3号")){
                        System.out.println("龙珠3号抢夺战开始，孙悟空开启超级赛亚人模式！");
                        Thread.sleep(5000);
                        System.out.println("龙珠3号抢夺战结束，孙悟空答应了，孙悟空拿到了3号龙珠！！");
                    }else{
                        System.out.println(Thread.currentThread().getName()+"收集到了！！！");
                    }
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },"龙珠"+i+"号").start();
        }
    }
}

7.3 信号灯

Semaphore的构造方法中传入的第一个参数时最大信号量（可以看成最大线程），每个信号量初始化为一个最多只能分发一个许可证。使用acquire方法获得许可证，release方法释放许可

场景：抢车位，6部汽车3个停车位

public class SemaphoreDemo {
    public static void main(String[] args) throws Exception {
        // 定义3个停车位
        Semaphore semaphore = new Semaphore(3);
        // 模拟6辆汽车停车
        for (int i = 1; i <= 6; i++) {
            Thread.sleep(100);
            new Thread(()->{
                try {
                    System.out.println(Thread.currentThread().getName()+"找车位ing");
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"汽车停车成功！");
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println(Thread.currentThread().getName()+"溜了溜了");
                    semaphore.release();
                }
            },"汽车"+i).start();
        }
    }
}