我們常見的并發鎖ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier都是基于AQS實現的，所以說不懂AQS實現原理的，就不能說了解Java鎖。
上篇文章講了AQS的加鎖流程，這篇文章再一塊看一下AQS具體源碼實現。
先回顧一下AQS的加鎖流程
1. AQS加鎖流程
AQS的加鎖流程并不復雜，只要理解了同步隊列和條件隊列，以及它們之間的數據流轉，就算徹底理解了AQS。
當多個線程競爭AQS鎖時，如果有個線程獲取到鎖，就把ower線程設置為自己
沒有競爭到鎖的線程，在同步隊列中阻塞（同步隊列采用雙向鏈表，尾插法）。
持有鎖的線程調用await方法，釋放鎖，追加到條件隊列的末尾（條件隊列采用單鏈表，尾插法）。
持有鎖的線程調用signal方法，喚醒條件隊列的頭節點，并轉移到同步隊列的末尾。
同步隊列的頭節點優先獲取到鎖
了解AQS加鎖流程之后，再去看源碼就容易理解了。
2. AQS的數據結構
// 繼承自AbstractOwnableSynchronizer，為了記錄哪個線程占用鎖
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
// 同步狀態，0表示無鎖，每次加鎖+1，釋放鎖-1
private volatile int state;
// 同步隊列的頭尾節點
private transient volatile Node head;
private transient volatile Node tail;
// Node節點，用來包裝線程，放到隊列中
static final class Node {
// 節點中的線程
volatile Thread thread;
// 節點狀態
volatile int waitStatus;
// 同步隊列的前驅節點和后繼節點
volatile Node prev;
volatile Node next;
// 條件隊列的后繼節點
Node nextWaiter;
}
// 條件隊列
public class ConditionObject implements Condition {
// 條件隊列的頭尾節點
private transient Node firstWaiter;
private transient Node lastWaiter;
}
}
首先AQS繼承自AbstractOwnableSynchronizer，其實是為了記錄哪個線程正在占用鎖。
public abstract class AbstractOwnableSynchronizer {
private transient Thread exclusiveOwnerThread;
// 設置占用鎖的線程
protected final void setExclusiveOwnerThread(Thread thread){
exclusiveOwnerThread = thread;
}
protected final Thread getExclusiveOwnerThread(){
return exclusiveOwnerThread;
}
}無論是同步隊列還是條件隊列中線程都需要包裝成Node節點。
雖然同步隊列和條件隊列都是由Node節點組成的，但是同步隊列中是使用prev和next組成雙向鏈表，nextWaiter只用來表示是共享模式還是排他模式。
條件隊列沒有使用到Node中prev和next屬性，而是使用nextWaiter組成單鏈表。
這個復用對象的設計思想值得我們學習。
同步隊列head節點是個啞節點，里面并沒有存儲線程對象。當然head節點也可以看成是給當前持有鎖的線程使用的。
Node節點的狀態（waitStatus）共有5種：
- 1 cancelled：表示線程已經被取消
- 0 初始化：Node節點的默認值
- -1 signal: 表示節點線程在釋放鎖后要喚醒同步隊列中的下一個節點線程
- -2 condition: 當前節點在條件隊列中
- -3 propagate: 釋放共享資源的時候會向后傳播釋放其他共享節點(用于共享模式)
3. AQS方法概覽
AQS支持獨占和共享兩種訪問資源的模式（獨占模式又叫排他模式）。
獨占模式的方法：
// 加鎖
acquire();
// 加可中斷的鎖
acquireInterruptibly();
// 一段時間內，加鎖不成功，就不加了
tryAcquireNanos(int arg, long nanosTimeout);
// 釋放鎖
release();
共享模式的方法：
// 加鎖
acquireShared();
// 加可中斷的鎖
acquireSharedInterruptibly();
// 一段時間內，加鎖不成功，就不加了
tryAcquireSharedNanos(int arg, long nanosTimeout);
// 釋放鎖
releaseShared();
獨占模式和共享模式的方法并沒有實現具體的加鎖、釋放鎖邏輯，AQS中只是定義了加鎖、釋放鎖的抽象方法。
留給子類實現的抽象方法：
// 加獨占鎖
protected boolean tryAcquire(int arg){
throw new UnsupportedOperationException();
}
// 釋放獨占鎖
protected boolean tryRelease(int arg){
throw new UnsupportedOperationException();
}
// 加共享鎖
protected int tryAcquireShared(int arg){
throw new UnsupportedOperationException();
}
// 釋放共享鎖
protected boolean tryReleaseShared(int arg){
throw new UnsupportedOperationException();
}
// 判斷是否是當前線程正在持有鎖
protected boolean isHeldExclusively(){
throw new UnsupportedOperationException();
}
這里就用到了設計模式中的模板模式，父類AQS定義了加鎖、釋放鎖的流程，子類ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier負責實現具體的加鎖、釋放鎖邏輯。
這不是個面試知識點嗎？
面試官再問你，你看過哪些框架源碼使用到了設計模式？
你就可以回答AQS源碼中用到了模板模式，巴拉巴拉，妥妥的加分項！
4. AQS源碼剖析
整個加鎖流程如下：
先看一下加鎖方法的源碼：
4.1 加鎖
// 加鎖方法，傳參是1
public final void acquire(int arg){
// 1. 首先嘗試獲取鎖，如果獲取成功，則設置state+1，exclusiveOwnerThread=currentThread（留給子類實現）
if (!tryAcquire(arg) &&
// 2. 如果沒有獲取成功，把線程組裝成Node節點，追加到同步隊列末尾
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
// 3. 加入同步隊列后，將自己掛起
selfInterrupt();
}
}
再看一下addWaiter方法源碼，作用就是把線程組裝成Node節點，追加到同步隊列末尾。
// 追加到同步隊列末尾，傳參是共享模式or排他模式
private Node addWaiter(Node mode){
// 1. 組裝成Node節點
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
if (pred != null) {
node.prev = pred;
// 2. 在多線程競爭不激烈的情況下，通過CAS方法追加到同步隊列末尾
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 3. 在多線程競爭激烈的情況下，使用死循環保證追加到同步隊列末尾
enq(node);
return node;
}
// 創建Node節點，傳參是線程，共享模式or排他模式
Node(Thread thread, Node mode) {
this.thread = thread;
this.nextWaiter = mode;
}
// 通過死循環的方式，追加到同步隊列末尾
private Node enq(final Node node){
for (; ; ) {
Node t = tail;
if (t == null) {
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
再看一下addWaiter方法外層的acquireQueued方法，作用就是：
在追加到同步隊列末尾后，再判斷一下前驅節點是不是頭節點。如果是，說明是第一個加入同步隊列的，就再去嘗試獲取鎖。
如果獲取鎖成功，就把自己設置成頭節點。
如果前驅節點不是頭節點，或者獲取鎖失敗，就逆序遍歷同步隊列，找到可以將自己喚醒的節點。
最后才放心地將自己掛起
// 追加到同步隊列末尾后，再次嘗試獲取鎖
final boolean acquireQueued(final Node node, int arg){
boolean failed = true;
try {
boolean interrupted = false;
for (; ; ) {
// 1. 找到前驅節點
final Node p = node.predecessor();
// 2. 如果前驅節點是頭結點，就再次嘗試獲取鎖
if (p == head && tryAcquire(arg)) {
// 3. 獲取鎖成功后，把自己設置為頭節點
setHead(node);
p.next = null;
failed = false;
return interrupted;
}
// 4. 如果還是沒有獲取到鎖，找到可以將自己喚醒的節點
if (shouldParkAfterFailedAcquire(p, node) &&
// 5. 最后才放心地將自己掛起
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
再看一下shouldParkAfterFailedAcquire方法，是怎么找到將自己喚醒的節點的？為什么要找這個節點？
// 加入同步隊列后，找到能將自己喚醒的節點
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node){
int ws = pred.waitStatus;
// 1. 如果前驅節點的狀態已經是SIGNAL狀態（釋放鎖后，需要喚醒后繼節點），就無需操作了
if (ws == Node.SIGNAL)
return true;
// 2. 如果前驅節點的狀態是已取消，就繼續向前遍歷
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 3. 找到了不是取消狀態的節點，把該節點狀態設置成SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
從代碼中可以很清楚的看到，目的就是為了找到不是取消狀態的節點，并把該節點的狀態設置成SIGNAL。
狀態是SIGNAL的節點，釋放鎖后，需要喚醒其后繼節點。
簡單理解就是：小弟初來乍到，特意來知會老大一聲，有好事，多通知小弟。
再看一下釋放鎖的邏輯。
4.2 釋放鎖
釋放鎖的流程如下：
釋放鎖的代碼邏輯比較簡單：
// 釋放鎖
public final boolean release(int arg){
// 1. 先嘗試釋放鎖，如果時候成功，則設置state-1，exclusiveOwnerThread=null（由子類實現）
if (tryRelease(arg)) {
Node h = head;
// 2. 如果同步隊列中還有其他節點，就喚醒下一個節點
if (h != null && h.waitStatus != 0)
// 3. 喚醒其后繼節點
unparkSuccessor(h);
return true;
}
return false;
}
再看一下喚醒后繼節點的方法
// 喚醒后繼節點
private void unparkSuccessor(Node node){
int ws = node.waitStatus;
// 1. 如果頭節點不是取消狀態，就重置成初始狀態
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
// 2. 如果后繼節點是null或者是取消狀態
if (s == null || s.waitStatus > 0) {
s = null;
// 3. 從隊尾開始遍歷，找到一個有效狀態的節點
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
// 3. 喚醒這個有效節點
if (s != null)
LockSupport.unpark(s.thread);
}
4.3 await等待
await等待的流程：
持有鎖的線程可以調用await方法，作用是：釋放鎖，并追加到條件隊列末尾。
// 等待方法
public final void await() throws InterruptedException {
// 如果線程已中斷，則中斷
if (Thread.interrupted())
throw new InterruptedException();
// 1. 追加到條件隊列末尾
Node node = addConditionWaiter();
// 2. 釋放鎖
int savedState = fullyRelease(node);
int interruptMode = 0;
// 3. 有可能剛加入條件隊列就被轉移到同步隊列了，如果還在條件隊列，就可以放心地掛起自己
while (!isOnSyncQueue(node)) {
LockSupport.park(this);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
// 4. 如果已經轉移到同步隊列，就嘗試獲取鎖
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
// 5. 清除條件隊列中已取消的節點
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
再看一下addConditionWaiter方法，是怎么追加到條件隊列末尾的？
// 追加到條件隊列末尾
private Node addConditionWaiter(){
Node t = lastWaiter;
// 1. 清除已取消的節點，找到有效節點
if (t != null && t.waitStatus != Node.CONDITION) {
unlinkCancelledWaiters();
t = lastWaiter;
}
// 2. 創建Node節點，狀態是-2（表示處于條件隊列）
Node node = new Node(Thread.currentThread(), Node.CONDITION);
// 3. 追加到條件隊列末尾
if (t == null)
firstWaiter = node;
else
t.nextWaiter = node;
lastWaiter = node;
return node;
}
4.4 signal喚醒
signal喚醒的流程：
喚醒條件隊列的頭節點，并追加到同步隊列末尾。
// 喚醒條件隊列的頭節點
public final void signal(){
// 1. 只有持有鎖的線程才能調用signal方法
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
// 2. 找到條件隊列的頭節點
Node first = firstWaiter;
if (first != null)
// 3. 開始喚醒
doSignal(first);
}
// 實際的喚醒方法
private void doSignal(Node first){
do {
// 4. 從條件隊列中移除頭節點
if ((firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
first.nextWaiter = null;
// 5. 使用死循環，一定要轉移一個節點到同步隊列
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
到底是怎么轉移到同步隊列末尾的？
// 實際轉移方法
final boolean transferForSignal(Node node){
// 1. 把節點狀態從CONDITION改成0
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
// 2. 使用死循環的方式，追加到同步隊列末尾（前面已經講過）
Node p = enq(node);
int ws = p.waitStatus;
// 3. 把前驅節點狀態設置SIGNAL（通知他，別忘了喚醒老弟）
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
LockSupport.unpark(node.thread);
return true;
}
5. 總結
看完整個AQS的源碼，是不是完全理解了AQS加鎖、釋放鎖、以及同步隊列和條件隊列數據流轉的邏輯了。
連AQS這么復雜的源碼你都搞清楚了，下篇帶你一塊學習ReentrantLock源碼，應該就輕松多了。
