Java AQS学习笔记

1. AQS介绍

AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。
包结构
AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器。

2. AQS原理

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

CLH(Craig,Landin,and Hagersten) 队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node）来实现锁的分配。

看个AQS(AbstractQueuedSynchronizer)原理图：
CLH
AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进行原子操作实现对其值的修改。

private volatile int state;//共享变量，使用volatile修饰保证线程可见性

状态信息通过procted类型的getState，setState，compareAndSetState进行操作

//返回同步状态的当前值
protected final int getState() {  
        return state;
}
 // 设置同步状态的值
protected final void setState(int newState) { 
        state = newState;
}
//原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值）
protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

2.1. AQS 对资源的共享方式

独占(Exclusive)：只有一个线程能执行，如ReentrantLock。又可分为公平锁和非公平锁：
- 公平锁(FairSync)：按照线程在队列中的排队顺序，先到者先拿到锁
- 非公平锁(NonfairSync)：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的
共享(Share)：多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。

ReentrantReadWriteLock 可以看成是组合式，因为ReentrantReadWriteLock也就是读写锁允许多个线程同时对某一资源进行读。

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在上层已经帮我们实现好了。

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

同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：

使用者继承AbstractQueuedSynchronizer并重写指定的方法。（这些重写方法很简单，无非是对于共享资源state的获取和释放）
将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。

这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用，下面简单的给大家介绍一下模板方法模式，模板方法模式是一个很容易理解的设计模式之一。

模板方法模式是基于”继承“的，主要是为了在不改变模板结构的前提下在子类中重新定义模板中的内容以实现复用代码。举个很简单的例子假如我们要去一个地方的步骤是：购票buyTicket()->安检securityCheck()->乘坐某某工具回家ride()->到达目的地arrive()。我们可能乘坐不同的交通工具回家比如飞机或者火车，所以除了ride()方法，其他方法的实现几乎相同。我们可以定义一个包含了这些方法的抽象类，然后用户根据自己的需要继承该抽象类然后修改 ride()方法。

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

isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。

默认情况下，每个方法都抛出 UnsupportedOperationException。这些方法的实现必须是内部线程安全的，并且通常应该简短而不是阻塞。AQS类中的其他方法都是final ，所以无法被其他类使用，只有这几个方法可以被其他类使用。

以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。
再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS(Compare and Swap)减1。等到所有子线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。

3. CountDownLatch （倒计时器）

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。

3.1. CountDownLatch 的两种典型用法

某一线程在开始运行前等待n个线程执行完毕。将 CountDownLatch 的计数器初始化为n ：new CountDownLatch(n) ，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await() 的线程就会被唤醒。

一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的 CountDownLatch 对象，将其计数器初始化为 1 ：new CountDownLatch(1) ，多个线程在开始执行任务前首先 coundownlatch.await()，当主线程调用 countDown() 时，计数器变为0，多个线程同时被唤醒。

3.2. CountDownLatch 的使用示例

public class CountDownLatchDemo {
    // 请求的数量
    private static final int threadCount = 50;

    public static void main(String[] args) throws InterruptedException {
        // 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
        // 这里需要注意：阿里编码规范中不建议使用Executors创建线程池，感兴趣的小伙伴自行Google去，此处为了直观就暂时不遵循，见谅
        ExecutorService threadPool = Executors.newFixedThreadPool(30);
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i + 1;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(new Random().nextInt(1000));// 模拟请求的耗时操作
                    System.out.println("threadnum:" + threadnum);
                    Thread.sleep(new Random().nextInt(1000));// 模拟请求的耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    countDownLatch.countDown();// 表示一个请求已经被完成
                }
            });
        }
        countDownLatch.await(); // 此处会阻塞主线程
        System.out.println("finished ...");
        threadPool.shutdown(); // 记得关闭线程池，不然main方法不会自动退出
    }
}

上面的代码中，我们定义了请求的数量为50，当这50个请求被处理完成之后，才会执行
System.out.println("finished ...");

3.3. CountDownLatch 的不足

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

4. CyclicBarrier(循环栅栏)

CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。

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

4.1. CyclicBarrier 的应用场景

举个例子：
我们需要召集7个法师去寻找龙珠，在出发前需要集合开个会(第一个屏障)，然后各自出发去寻找龙珠，找到龙珠后需要在一起(第二个屏障)召唤神龙；

4.2. CyclicBarrier 的使用示例

public class CyclicBarrierDemo {

    private static final int MAX_THREAD_NUM = 7;
    private static int mission = 1; // 屏障 {1: 召集7位法师, 2: 集齐7颗龙珠召唤神龙}

    public static void main(String[] args) {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(MAX_THREAD_NUM);
        // 两个任务使用同一个屏障
        CyclicBarrier cyclicBarrier = new CyclicBarrier(MAX_THREAD_NUM, ()->{
            if(mission == 1){
                // 屏障1： 召集法师任务已完成
                System.out.println("已经召集齐7名法师，任务已宣读，出发寻找龙珠");
                mission = 2; // 任务1已完成，设置任务2：寻找龙珠
            }else{
                // 屏障2： 集齐龙珠已完成
                System.out.println("龙珠已集齐，开始召唤神龙");
            }
        });
        for (int i = 0; i < MAX_THREAD_NUM; i++) {
            final int num = i + 1;
            threadPool.execute(()->{
                try {
                    Thread.sleep(new Random().nextInt(1000)); // 模拟召集过程
                    System.out.println("第" + num + "名法师已就位");
                    cyclicBarrier.await(); // 屏障1阻塞线程
                    // 必须等7为法师全部召集后出发寻找龙珠
                    System.out.println("第" + num + "名法师已出发");
                    Thread.sleep(new Random().nextInt(1000)); // 模拟寻找龙珠过程
                    System.out.println("第" + num + "颗龙珠已找到");
                    cyclicBarrier.await(); // 屏障2阻塞线程
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

运行结果，如下：

第5名法师已就位
第6名法师已就位
第3名法师已就位
第1名法师已就位
第7名法师已就位
第4名法师已就位
第2名法师已就位
已经召集齐7名法师，任务已宣读，出发寻找龙珠
第2名法师已出发
第5名法师已出发
第3名法师已出发
第4名法师已出发
第6名法师已出发
第7名法师已出发
第1名法师已出发
第5颗龙珠已找到
第3颗龙珠已找到
第7颗龙珠已找到
第2颗龙珠已找到
第1颗龙珠已找到
第4颗龙珠已找到
第6颗龙珠已找到
龙珠已集齐，开始召唤神龙

可以看到当线程数量也就是请求数量达到我们定义的 7 个的时候， await方法之后的方法才被执行。

4.3. CyclicBarrier和CountDownLatch的区别

CountDownLatch是计数器，只能使用一次，而CyclicBarrier的计数器提供reset功能，可以多次使用。但是我不那么认为它们之间的区别仅仅就是这么简单的一点。我们来从jdk作者设计的目的来看，javadoc是这么描述它们的：

CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.(CountDownLatch: 一个或者多个线程，等待其他多个线程完成某件事情之后才能执行；)

CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.(CyclicBarrier : 多个线程互相等待，直到到达同一个同步点，再继续一起执行。)

对于CountDownLatch来说，重点是“一个线程（多个线程）等待”，而其他的N个线程在完成“某件事情”之后，可以终止，也可以等待。而对于CyclicBarrier，重点是多个线程，在任意一个线程没有完成，所有的线程都必须等待。

CountDownLatch是计数器，线程完成一个记录一个，只不过计数是递减，而CyclicBarrier更像是一个阀门，需要所有线程都到达，阀门才能打开，然后继续执行。

CountDownLatch	CyclicBarrier
减计数方式	加计数方式
计数器为0时释放所有等待的线程	计数器达到指定值时释放所有等待线程
计数器为0，无法重置	计数器达到指定值时，重置为0
调用countDown方法计数器减1，调用await方法只进行阻塞，对计数器没有影响	调用awati方法计数器加1，若加1后值不等于构造方法初始化的值，线程阻塞
不可重复利用	可重复利用

5. Semaphore(信号量)-允许多个线程同时访问

synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。示例代码如下：

public class SemaphoreDemo {
    // 请求的数量
    private static final int threadCount = 50;

    public static void main(String[] args) throws InterruptedException {
        // 创建一个具有固定线程数量的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(30);
        // 一次只能允许执行的线程数量。
        final Semaphore semaphore = new Semaphore(20);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            threadPool.execute(() -> {
                try {
                    semaphore.acquire();// 获取一个许可，所以可运行线程数量为20/1=20
                    Thread.sleep(new Random().nextInt(1000));// 模拟请求的耗时操作
                    System.out.println("threadNum:" + threadNum);
                    Thread.sleep(new Random().nextInt(1000));// 模拟请求的耗时操作
                    semaphore.release();// 释放一个许可
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        System.out.println("finished ...");
        threadPool.shutdown();
    }
}

执行 acquire 方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个 release 方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有实际的许可证这个对象，Semaphore只是维持了一个可获得许可证的数量。 Semaphore经常用于限制获取某种资源的线程数量。

当然一次也可以一次拿取和释放多个许可，不过一般没有必要这样做：

semaphore.acquire(5);// 获取5个许可，所以可运行线程数量为20/5=4
test(threadnum);
semaphore.release(5);// 获取5个许可，所以可运行线程数量为20/5=4

除了 acquire方法之外，另一个比较常用的与之对应的方法是tryAcquire方法，该方法如果获取不到许可就立即返回false。

Semaphore 有两种模式，公平模式和非公平模式。

公平模式：调用acquire的顺序就是获取许可证的顺序，遵循FIFO；
非公平模式：抢占式的。
Semaphore 对应的两个构造方法如下：

public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

这两个构造方法，都必须提供许可的数量，第二个构造方法可以指定是公平模式还是非公平模式，默认非公平模式。

参考资料：
https://www.cnblogs.com/waterystone/p/4920797.html

https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html

https://blog.csdn.net/qq_19431333/article/details/70212663

https://blog.csdn.net/u010185262/article/details/54692886

https://blog.csdn.net/tolcf/article/details/50925145?utm_source=blogxgwz0