引子
前文《面试必考AQS-排它锁的申请与释放》已经对AQS中对于排它锁的申请与释放流程进行了总结。而对于申请与释放，在AQS中提现的是与锁并无关系，而是针对同步队列的操作，向同步队列中添加、移除Node实例对象，操作Node中的线程对象。而我们日常使用的锁类，只是表象，何时可以加锁、解锁，达到何种条件才算加锁成功、解锁成功，这才是AQS锁实现的功能。接下来将从源码层面看一下，排它锁的申请与释放在AQS中具体是怎样实现的。
排它锁的申请
再看一次申请流程的大致方法调用：
public final void acquire(int arg){...} // 获取排它锁的入口
# protected boolean tryAcquire(int arg); // 尝试直接获取锁
final boolean acquireQueued(final Node node, int arg) {...} // AQS中获取排它锁流程整合
private Node addWaiter(Node mode){...} // 将node加入到同步队列的尾部
# protected boolean tryAcquire(int arg); // 如果当前node的前置节点pre变为了head节点，则尝试获取锁（因为head可能正在释放）
private void setHead(Node node) {...} // 设置 同步队列的head节点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {...} // 如果获取锁失败，则整理队中节点状态，并判断是否要将线程挂起
private final boolean parkAndCheckInterrupt() {...} // 将线程挂起，并在挂起被唤醒后检查是否要中断线程（返回是否中断）
private void cancelAcquire(Node node) {...} // 取消当前节点获取排它锁，将其从同步队列中移除
static void selfInterrupt() {...} // 操作将当前线程中断
先看一下入口方法acquire(int arg)的代码。
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
源码上是先调用tryAcquire()方法，如果返回false，则进入acquireQueued()；由于tryAcquire()是由子类实现的，我们暂时先不看，留到以后梳理AQS实现类时再串讲。
那么从tryAcquire()从方法名来讲就是“尝试获取锁”，先假设return=false，也就是“尝试获取锁失败”，继续执行调用acquireQueued()。
在进入acquireQueued()之前，会先调用一次addWaiter(),传入了一个Node.EXCLUSIVE对象；Node.EXCLUSIVE在前文有介绍，是Node类中一个实例变量成员，用于标记排他类型的Node实例。
那么看一下addWaiter()方法，直接看一下方法内注释吧。
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode); // 用入参mode=Node.EXCLUSIVE,创建了一个Node实例。
// 将新创建的节点 加入 同步队列的尾部
Node pred = tail; // 拿到同步队列尾指针
if (pred != null) {
node.prev = pred; // 追加到尾部
if (compareAndSetTail(pred, node)) { // cas方式，更新尾指针指向 新节点node
pred.next = node;
return node;
}
}
// 如果上述方式加入队列失败，进入enq(node)方法。
enq(node);
return node;
}
private Node enq(final Node node) {
for (;;) { // 无限尝试
Node t = tail;
if (t == null) {
// 尾结点不能指向为null，说明队列为null，需要初始化同步队列的头尾指针
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 这段代码的含义，与addWaiter()中的一致，也就是不停尝试将节点加入到同步队列
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
那么addWaiter()方法就一个目的：将新的node加入到同步队列的尾部，并将node返回。
接下来继续调用acquireQueued()方法，我们看看它做了什么:
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;// 一个状态标记，goto t1
try {
boolean interrupted = false; // 一个状态标记,goto t2
for (;;) {
final Node p = node.predecessor(); // 获取node的前置节点p，前文有介绍过
if (p == head && tryAcquire(arg)) { // 如果p是头节点，立即尝试获取锁（注意只有队列head的下一个节点才能去获取锁）
setHead(node); // 如果返回true，说明获取锁成功，设置head为当前节点（说明原有head已经释放锁）
p.next = null; // help GC
failed = false;
return interrupted; // t2',将中断标识返回
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true; // t2,是否中断线程的标记,goto t2'
}
} finally {
if (failed) // t1,状态标识的值，决定是否调用cancelAcquire()
cancelAcquire(node);
}
}
流程比较清晰，一个for(;;)，循环尝试获取锁，如果节点到达同步队列的head之后，则尝试申请锁，申请成功返回，否则调用shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()，我们继续往下看。
// 入参：pred 就是当前节点的前置节点，node就是当前节点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus; // 获取前置节点的状态
if (ws == Node.SIGNAL) // SIGNAL 代表 节点等待被唤醒，可以理解为是一种阻塞状态的标记
/*
* pred节点为SIGNAL状态，可以认为node允许阻塞
*/
return true;
if (ws > 0) {
// 由于ws的状态只有CANCEL是大于0，因此节点无效，前置节点可以从队列移除
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0); // 遍历同步队列中，node前面的所有节点，将CANCEL状态的都移除
pred.next = node;
} else {
// 如果前置节点状态 小于0，说明是正常节点（但不是SIGNAL)，
// 先cas设置为SIGNAL(标记存在后置节点)，然后交给外层for(;;)再次尝试申请锁
// else中不返回true的目的是：
// 防止过早进入parkAndCheckInterrupt()，而应该再次尝试申请锁（临近状态控制）
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
如果shouldParkAfterFailedAcquire()返回true，则进入parkAndCheckInterrupt()方法，这里只做了一件事，将线程挂起。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this); // 挂起当前线程；由此线程等待被唤醒
// other thread going to work..
return Thread.interrupted(); // 当线程被唤醒后，返回线程是否中断
}
我们再回到acquireQueued()方法看一下，注意看注释：
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 这里的工作是：检查前置节点状态，如果是SIGNAL，则让当前node代表的线程挂起
// 如果不是SIGNAL，则会继续for(;;)努力申请锁。
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// 如果parkAndCheckInterrupt()==true说明线程被中断，需要设置interrupted标记
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
再看看cancelAcquire()内部实现：
private void cancelAcquire(Node node) {
// Ignore if node doesn't exist
if (node == null)
return;
// 节点操作取消申请，清空线程对象
node.thread = null;
// 将同步队列中node前的节点，移出队列
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
// preNext 是清理后的同步队列的pre节点的下一个有效节点
Node predNext = pred.next;
// Can use unconditional write instead of CAS here.
// After this atomic step, other Nodes can skip past us.
// Before, we are free of interference from other threads.
node.waitStatus = Node.CANCELLED;
// 如果node在队尾，则将队尾tail指向pred节点
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);// 并将pred节点的next指向predNext。
// 以上都是在整理同步队列节点；node在队尾，直接丢弃即可
} else {
// If successor needs signal, try to set pred's next-link
// so it will get one. Otherwise wake it up to propagate.
int ws;
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
// t3 能进入这里的条件是：
// 1、前置节点不是head节点
// 并且
// 2、前置节点状态是SIGNAL 或者 (前置节点状态小于0 并且 可以修改为SIGNAL)
// 并且
// 3、前置节点的线程不为null
// 以上，都是在判定 pred节点是否为一个有效节点
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
// 将前置节点的next指向当前node的next，从同步队列中移除node
} else {
// 如果t3 的条件未达到，
// 则手动唤醒node代表的线程
// (假设node还在被挂起，则可以交给acquireQueued()中的for(;;) 重新搞一波)
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
以上，就是申请排它锁的全部流程，其中比较关键的方法，都是涉及到waitStatus的值变化的方法，如shouldParkAfterFailedAcquire()、parkAndCheckInterrupt()、cancelAcquire()，思路要理清才能搞明白。
重新回忆下申请锁都做了什么：
1、先交给子类去尝试申请锁，如果申请成功了，则结束流程；
2、否则将申请线程包装为node节点，并加入同步队列
3、循环检查当前节点的前置节点是否为head，如果是则申请获取锁
4、否则检查节点状态，并将线程挂起，等待前面有节点释放锁后，来主动唤醒该线程
5、将CANCEL状态的节点清理掉。
锁既然已经申请到了，那么不可避免的就要释放；接下来再分析一下释放锁的源码。
排它锁的释放
再看一次释放流程的大致方法调用：
public final boolean release(int arg) {...} // 释放排它锁的入口
# protected boolean tryRelease(int arg); // 尝试直接释放锁
private void unparkSuccessor(Node node) {...} // 唤醒后继节点
先看入口方法release()的工作：
public final boolean release(int arg) {
if (tryRelease(arg)) { // 同样先让子类执行tryRelease()来尝试释放锁，
// 这回是如果成功了继续
Node h = head;
if (h != null && h.waitStatus != 0)
// head如果不为null并且状态不是0，则调用unparkSuccessor()
unparkSuccessor(h);
return true;
}
return false;
}
释放锁具体怎么释放，交给了子类去操作，那么说明一点，tryRelease()中并不涉及同步队列的操作。而unparkSuccessor(h);中做的事情，才是AQS的关键。
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 修改node节点状态为SIGNAL
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
Node s = node.next;
if (s == null || s.waitStatus > 0) { // head的下一个节点，如果为CANCEL状态
s = null;
// 清理同步队列，注意这里是从尾部开始向前清理的
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
// 由于是从尾部清理，因此s最后的值应该是同步队列中第一个waitState<=0的节点
// 那么unpark()操作的就是同步队列中第一个等待被唤醒的节点
if (s != null)
LockSupport.unpark(s.thread);
}
以上就是释放锁的流程；重新回忆一下释放锁到底干了什么。
1、先交给子类去尝试释放锁，如果成功则处理同步队列的节点
2、将同步队列中的无效节点移除，然后将队列中node之后第一个有效节点唤醒
其实就这么简单，但是代码很精妙，尤其是从尾部遍历同步队列的思路。
尾声
对于AQS中排它锁的申请与释放，思路是比较清晰的，而且行为方向单一，就是针对同步队列的入队与出队操作，以及在某些情况下针对同步队列进行遍历；再加上LockSupport的park和unpark调用，来控制线程状态。
这就是AQS的一部分，仔细分析源码，其实没那么复杂。