【面试题】AQS

1. AQS 原理

AQS 核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制 AQS 是用 CLH 队列锁实现的，即将暂时获取不到锁的线程加入到队列中（底层实现的数据结构是一个双向链表）。

AQS 底层使用了模板方法模式

AQS 使用了模板方法模式，自定义同步器时需要重写下面几个 AQS 提供的模板方法：

2. AQS 定义两种资源共享方式

2.1 Exclusive（独占）

只有一个线程能执行，如 ReentrantLock。

2.2 Share（共享）

多个线程可同时执行，如Semaphore、CountDownLatch、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。
ReentrantReadWriteLock 可以看成是组合式，因为 ReentrantReadWriteLock 也就是读写锁允许多个线程同时对某一资源进行读。

它的所有子类中，要么实现并使用了它的独占功能的api，要么使用了共享锁的功能，而不会同时使用两套api，即便是最有名的子类ReentrantReadWriteLock也是通过两个内部类读锁和写锁分别实现了两套api来实现的。

3. CountDownLatch

任务分成N个子任务执行，state初始化为N(与线程个数保持一致)，这N个线程是并行的，每个子线程执行完countDown()一次，state CAS自减1，等待所有线程都执行完，state恢复0，会unpark主调用线程，主线程继续执行。

CountDownLatch 的不足

CountDownLatch 是一次性的，计数器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当 CountDownLatch 使用完毕后，它不能再次被使用。

3.1 countDown() 计数器-1

3.2 await() 调用线程被阻塞

主要有两个方法，当线程调用await()方法的时候，调用线程会被阻塞，当其线程调用countDown()方法的时候会将计数器-1（调用countDown方法的线程不会阻塞），当计数器的值变为0的时候，调用await()方法被阻塞的线程被唤醒

class Main {
    public static void main(String[] args) {

        CountDownLatch countDownLatch=new CountDownLatch(7);

        for (int i = 0; i < 7; i++) {
            final String iStr=String.valueOf(i);
          new Thread(()->{
              System.out.println("同学"+iStr+"离开");
              countDownLatch.countDown();   //计数器-1
          },String.valueOf(i)).start();
        }

        try {
            countDownLatch.await();  //能够阻塞线程 直到调用7次countDown() 方法才释放线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("班长关灯走人");
    }
}

4. CyclicBarrier

CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障 拦截的线程才会继续干活。CyclicBarrier 默认的构造方法是 CyclicBarrier(int parties) ，其参数表示屏障拦截的线程数量，每个线程调用await 方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。

 public static void main(String[] args) {

        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("召唤神龙！");
        });

        for (int i = 0; i < 7; i++) {
            final String iStr = String.valueOf(i);
            new Thread(() -> {
                try {
                    System.out.println("收集第"+iStr+"颗龙珠");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, iStr).start();
        }
    }

5. Semaphore 信号灯

Semaphore 对应的两个构造方法如下：

Semaphore与CountDownLatch一样，也是共享锁的一种实现。它默认构造AQS的state为permits。当执行任务的线程数量超出permits,那么多余的线程将会被放入阻塞队列Park，并自旋判断state是否大于0。只有当state大于0的时候，阻塞的线程才能继续执行，此时先前执行任务的线程继续执 行release方法，release方法使得state的变量会加1，那么自旋的线程便会判断成功。如此，每次只有最多不超过permits数量的线程能自旋成功，便限制了执行任务线程的数量。

5.1 acquire()获得资源

5.2 release()释放资源

主要有两个作用，一个是多个共享资源互斥使用，另一个是并发线程数控制。
两个调用方法，acquire()获得资源，release()释放资源

 public static void main(String[] args) {

        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"进入停车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开停车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }

CyclicBarrier 和 CountDownLatch 的区别

ountDownLatch 是计数器，只能使用一次，而 CyclicBarrier 的计数器提供 reset 功能，可以多次使用。
对于 CountDownLatch 来说，重点是“一个线程（多个线程）等待”，而其他的 N 个线程在完成“某件事情”之后，可以终止，也可以等待。而对于 CyclicBarrier，重点是多个线程，在任意一个线程没有完成，所有的线程都必须等待。
CountDownLatch 是计数器，线程完成一个记录一个，只不过计数不是递增而是递减，而CyclicBarrier 更像是一个阀门，需要所有线程都到达，阀门才能打开，然后继续执行。

AQS：http://www.imooc.com/article/293135
https://blog.csdn.net/ywl470812087/article/details/128430061