Semaphore、CountDownLatch、CyclicBarrier原理

对于AQS的原理和ReentrantLock原理不熟悉的小伙伴可以参考上篇文章（并发编程之AQS原理及其ReentrantLock原理），这篇文章我们再继续深入看下AQS
一、Semaphore底层实现（author:Doug Lea）

        //信号量  共享锁
        Semaphore windows = new Semaphore(3);

        for(int i=0; i<5; i++) {
            Thread t = new Thread(() -> {
                try {
                    windows.acquire();
                    System.out.println("当前线程" + Thread.currentThread().getId() + "正在执行");
                    Thread.sleep(5000);
                    windows.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            t.start();
        }

怎么理解这个信号量呢，其实我们可以类比生活中，在超市自助结账，比如现在有3台自助结账的机器，这个时候我们买完东西，可以选择其中一个机器，进行排队，结账。

注：唤醒的传递性
二、CountDownLatch

public static void main(String[] args) {
        //闭锁 
        CountDownLatch countDownLatch = new CountDownLatch(3);

        for (int i=0; i<2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    countDownLatch.countDown();
                    try {
                        countDownLatch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread() + "end");
                }
            }).start();
        }
    }

运行上面的代码，大家会发现阻塞了，阻塞的主要原因就是因为countDown没能到3，所以就一直阻塞在await这里了，如果我们把for循环的结束条件改成大于等于3的值，那么这个程序就不会出现阻塞的情况
三、CyclicBarrier（循环屏障，打麻将三缺一的意思，凑不齐一桌，就打不了麻将）

public static void main(String[] args) throws Exception{
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        for(int i=0; i<5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "开始等待其它线程");
                    try {
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "开始执行");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "执行结束");
                }
            }).start();
        }
    }

上面程序运行的结果

Thread-4开始等待其它线程
Thread-2开始等待其它线程
Thread-0开始等待其它线程
Thread-3开始等待其它线程
Thread-1开始等待其它线程
Thread-2开始执行
Thread-1开始执行
Thread-3开始执行
Thread-3执行结束
Thread-2执行结束
Thread-1执行结束

程序一直处于阻塞状态

下面是循环屏障，底层实现