11.1 AQS简介
AQS是 AbstractQueuedSynchronizer 的简称，即 抽象队列同步器，从字面意思上理解：
- 抽象：抽象类，只实现一些主要逻辑，有些方法由子类实现。
- 队列：使用先进先出（FIFO）队列存储数据。
- 同步：实现了同步的功能。
那AQS有什么用呢？AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的同步器，比如我们提到的ReentrantLock，Semaphore，ReenteantReadWriteLock，SynchronousQueue, FutrueTask等等皆是基于AQS的。
当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器，只要之类实现它的几个protected方法就可以了。
11.2 AQS的数据结构
AQS内部使用了一个volatile的变量state来作为资源的标识。同时定义了几个获取和改版state的protected方法，子类
可以覆盖这些方法来实现自己的逻辑：
getState()
setState()
compareAndSetState()这三种叫做均是原⼦操作，其中compareAndSetState的实现依赖于Unsafe的compareAndSwapInt()⽅法。
⽽AQS类本身实现的是⼀些排队和阻塞的机制，⽐如具体线程等待队列的维护（如获取资源失败⼊队/唤醒出队等）。它内部使⽤了⼀个先进先出（FIFO）的双端队列，并使⽤了两个指针head和tail⽤于标识队列的头部和尾部。其数据结构如图：
但它并不是直接存储线程，而是存储拥有线程的Node节点。
11.3 资源共享模式
资源有两种共享模式，或者说两种同步方式：
- 独占模式（Exclusive）：资源是独占的，一次只能一个线程获取，如ReetrantLock。
- 共享模式（Share）：同时可以被多个线程获取，具体的资源个数可以通过参数指定。如Semaphore/CountDownLatch。
一般情况下，子类只需要根据需求实现其中一种模式，当然也有同时实现两种模式的同步类，如ReadWriteLock。
AQS中关于这两种资源共享模式的定义源码（均在内部类Node中）。我们来看看Node的结构：
static final class Node {
/** 标记⼀个结点（对应的线程）在共享模式下等待 */
static final Node SHARED = new Node();
/** 标记⼀个结点（对应的线程）在独占模式下等待 */
static final Node EXCLUSIVE = null;
/** waitStatus的值，表示该结点（对应的线程）已被取消 */
static final int CANCELLED = 1;
/** waitStatus的值，表示后继结点（对应的线程）需要被唤醒 */
static final int SIGNAL = -1;
/** waitStatus的值，表示该结点（对应的线程）在等待某⼀条件 */
static final int CONDITION = -2;
/**
* waitStatus的值，新head节点需要继续唤醒后继结点
*/
static final int PROPAGATE = -3;
// 等待状态，取值范围，-3，-2，-1，0，1
volatile int waitStatus;
// 前驱结点
volatile Node prev;
// 后继结点
volatile Node next;
// 结点对应的线程
volatile Thread thread;
// 等待队列⾥下⼀个等待条件的结点
Node nextWaiter;
/**
* 判断共享模式的⽅法
*/
final boolean isShared() {
return nextWaiter == SHARED;
}
/**
* Returns previous node, or throws NullPointerException if null.
* Use when predecessor cannot be null. The null check could
* be elided, but is present to help the VM.
*
* @return the predecessor of this node
*/
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
Node() { // Used to establish initial head or SHARED marker
}
Node(Thread thread, Node mode) { // Used by addWaiter
this.nextWaiter = mode;
this.thread = thread;
}
Node(Thread thread, int waitStatus) { // Used by Condition
this.waitStatus = waitStatus;
this.thread = thread;
}
}
// AQS⾥⾯的addWaiter私有⽅法
private Node addWaiter(Node mode) {
// 使⽤了Node的这个构造函数
Node node = new Node(Thread.currentThread(), mode);
// 尝试询问的捷径; 失败时备份到充分询问
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}注意：通过Node我们可以实现两个队列，⼀是通过prev和next实现CLH队列(线程同步队列,双向队列)，⼆是nextWaiter实现Condition条件上的等待线程队列(单向队列)，这个Condition主要⽤在ReentrantLock类中。
11.4 AQS的主要方法源码解析
AQS的设计是基于模板⽅法模式的，它有⼀些⽅法必须要⼦类去实现的，它们主要有：
- isHeldExclusively()：该线程是否正在独占资源。只有⽤到condition才需要去实现它。
- tryAcquire(int)：独占⽅式。尝试获取资源，成功则返回true，失败则返回false。
- tryRelease(int)：独占⽅式。尝试释放资源，成功则返回true，失败则返回false。
- tryAcquireShared(int)：共享⽅式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可⽤资源；正数表示成功，且有剩余资源。
- tryReleaseShared(int)：共享⽅式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。
这些⽅法虽然都是 protected ⽅法，但是它们并没有在AQS具体实现，⽽是直接抛出异常（虽然不知道这⾥为什么不使⽤抽象⽅法的实现⽅式）：
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}⽽AQS实现了⼀系列主要的逻辑。下⾯我们从源码来分析⼀下获取和释放资源的主要逻辑：
11.4.1 获取资源
获取资源的⼊⼝是acquire(int arg)⽅法。arg是要获取的资源的个数，在独占模式下始终为1。我们先来看看这个⽅法的逻辑：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}⾸先调⽤tryAcquire(arg)尝试去获取资源。前⾯提到了这个⽅法是在⼦类具体实现的。
如果获取资源失败，就通过addWaiter(Node.EXCLUSIVE)⽅法把这个线程插⼊到等待队列中。其中传⼊的参数代表要插⼊的Node是独占式的。这个⽅法的具体实现：
private Node addWaiter(Node mode) {
// ⽣成该线程对应的Node节点
Node node = new Node(Thread.currentThread(), mode);
// 将Node插⼊队列中
Node pred = tail;
if (pred != null) {
node.prev = pred;
// 使⽤CAS尝试，如果成功就返回
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 如果等待队列为空或者上述CAS失败，再⾃旋CAS插⼊
enq(node);
return node;
}
// ⾃旋CAS插⼊等待队列
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}上⾯的两个函数⽐较好理解，就是在队列的尾部插⼊新的Node节点，但是需要注意的是由于AQS中会存在多个线程同时争夺资源的情况，因此肯定会出现多个线程同时插⼊节点的操作，在这⾥是通过CAS⾃旋的⽅式保证了操作的线程安全性。
OK，现在回到最开始的aquire(int arg)⽅法。现在通过addWaiter⽅法，已经把⼀个Node放到等待队列尾部了。⽽处于等待队列的结点是从头结点⼀个⼀个去获取资源的。具体的实现我们来看看acquireQueued⽅法：
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
//自旋
for (;;) {
final Node p = node.predecessor();
// 如果node的前驱结点p是head，表示node是第⼆个结点，就可以尝试去获取资源了
if (p == head && tryAcquire(arg)) {
// 拿到资源后，将head指向该结点。
// 所以head所指的结点，就是当前获取到资源的那个结点或null。
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 如果⾃⼰可以休息了，就进⼊waiting状态，直到被unpark()
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}这⾥parkAndCheckInterrupt⽅法内部使⽤到了LockSupport.park(this)，顺便简单介绍⼀下park。
LockSupport类是Java 6
引⼊的⼀个类，提供了基本的线程同步原语。LockSupport实际上是调⽤了Unsafe类⾥的函数，归结到Unsafe⾥，只有两个函数：
- park(boolean isAbsolute, long time)：阻塞当前线程
- unpark(Thread jthread)：使给定的线程停⽌阻塞
所以结点进⼊等待队列后，是调⽤park使它进⼊阻塞状态的。只有头结点的线程是处于活跃状态的。
当然，获取资源的⽅法除了acquire外，还有以下三个：
- acquireInterruptibly：申请可中断的资源（独占模式）
- acquireShared：申请共享模式的资源
- acquireSharedInterruptibly：申请可中断的资源（共享模式）
可中断的意思是，在线程中断时可能会抛出 InterruptedException
总结起来的⼀个流程图：
11.4.2 释放资源
释放资源相比与获取资源来说，会简单许多。在AQS中只有一小段实现。源码：
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
private void unparkSuccessor(Node node) {
/*
* 如果状态是负数，尝试把它设置为0
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* 得到头结点的后继结点head.next
*/
Node s = node.next;
// 如果这个后继结点为空或者状态⼤于0
// 通过前⾯的定义我们知道，⼤于0只有⼀种可能，就是这个结点已被取消
if (s == null || s.waitStatus > 0) {
s = null;
// 等待队列中所有还有⽤的结点，都向前移动
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
// 如果后继结点不为空，
if (s != null)
LockSupport.unpark(s.thread);
}
