JUC辅助类，减少计数，循环栅栏，信号灯机制代码示例

JUC 中提供了三种常用的辅助类，通过这些辅助类可以很好的解决线程数量过多时 Lock 锁的频繁操作。这三种辅助类为：
• CountDownLatch: 减少计数
• CyclicBarrier: 循环栅栏
• Semaphore: 信号灯

一、CountDownLatch: 减少计数

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <=6 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"离开了教室");
    
            },String.valueOf(i)).start();
        }
        System.out.println("班长锁门离开了");
    }
}

模拟了6个同学离开教室，最后班长锁门离开的情况，但是线程执行的时间不确定，可能导致班长先离开的情况：

CountDownLatch 类可以设置一个计数器，创建countDownLatch对象的时候，传入参数6，表示计数器的值是6，
然后通过 countDown 方法来进行减 1 的操作，使用 await 方法等待计数器不大于 0，然后继续执行 await 方法之后的语句。
• CountDownLatch 主要有两个方法，当一个或多个线程调用 await 方法时，这些线程会阻塞
• 其它线程调用 countDown 方法会将计数器减 1(调用 countDown 方法的线程不会阻塞)
• 当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {

        CountDownLatch  countDownLatch=new CountDownLatch(6);
        for (int i = 1; i <=6 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"离开了教室");
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
                countDownLatch.await();
        System.out.println("班长锁门离开了");
    }
}

二：CyclicBarrier: 循环栅栏

public class CyclicBarrierDemo {

    private static final int NUMBER=7;
    public static void main(String[] args) {
		 System.out.println("龙珠集齐，出来吧神龙");
        for (int i = 1; i <=7 ; i++) {
            new Thread(()->{
                System.out.println("拿到了第"+Thread.currentThread().getName()+"颗龙珠");
            },String.valueOf(i)).start();
        }
    }
}

模拟集齐七颗龙珠召唤神龙，但是因为线程执行顺序的关系，导致没集齐就开始召唤了

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

public class CyclicBarrierDemo {

    private static final int NUMBER=7;
    public static void main(String[] args) {

        CyclicBarrier cyclicBarrier=new CyclicBarrier(NUMBER,()->{
            System.out.println("龙珠集齐，出来吧神龙");
        });

        for (int i = 1; i <=7 ; i++) {
            new Thread(()->{
                System.out.println("拿到了第"+Thread.currentThread().getName()+"颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

三、Semaphore: 信号灯

public class SemaphoreDemo {
    public static void main(String[] args) {
       Semaphore  semaphore=new Semaphore(3);

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                try {
                   semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"号车抢到了车位");

                    TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
   		          semaphore.release();
                    System.out.println(Thread.currentThread().getName()+"---------号车离开了车位");
                }

            },String.valueOf(i)).start();
        }
    }
}

Semaphore 的构造方法中传入的第一个参数是最大信号量（可以看成最大线程池），每个信号量初始化为一个最多只能分发一个许可证。使用 acquire 方法获得许可证，release 方法释放许可
模拟抢车位, 6 部汽车 3 个停车位，抢到车位，离开车位的过程