最近一直在研究AQS的原始碼，希望可以更深刻的理解AQS的實現原理。雖然網上有很多關於AQS的原始碼分析，但是看完以後感覺還是一知半解。於是，我將自己的整個理解過程記錄下來了，希望對大家有所幫助。
基本原理
AQS是Java中鎖的基礎，主要由兩個佇列組成。一個佇列是同步佇列，另一個是條件佇列。
同步佇列的原理
- 同步佇列的佇列頭部是
head，佇列尾部是tail節點，head節點是一個空節點，同步佇列是一個雙向連結串列，通過next和prev連線所有節點 - 所有的執行緒在競爭鎖的時候都會建立一個
Node節點，執行緒與節點繫結在一起，（如果是同步鎖和排他鎖不同之處是通過nextWaiter來區分的）並且新增到同步佇列的尾部 head的第一個節點獲取鎖，其餘節點都需要等待被喚醒- 同步佇列中的節點會存在取消和
null的情況（如：執行緒超時中斷、執行緒更新節點的中間態），被取消和null的節點不能被喚醒，將會被視為無效節點 - 一個執行緒只能被有效的前驅節點（取消和
null的節點除外）喚醒 - 持有鎖的執行緒只能是有一個，其他有效節點對應的執行緒都會被掛起
條件佇列的原理
- 一個同步佇列可以對應多個條件佇列
- 條件佇列是一個單向連結串列，通過
nextWaiter來連線起來，條件佇列的頭節點是firstWaiter，尾節點是lastWaiter - 某個條件佇列中滿足條件的節點（被
signal或signalAll方法喚醒的節點）才會被轉移到同步佇列 - 條件佇列中的被轉移到同步佇列的節點是從頭節點開始，條件佇列中被阻塞的執行緒會新增到佇列的尾部
同步佇列的實現
首先，瞭解以下同步佇列中佇列的節點Node的資料結構
static final class Node {
/** 共享鎖的標識 */
static final Node SHARED = new Node();
/** 排他鎖的標識 */
static final Node EXCLUSIVE = null;
/** 執行緒取消 */
static final int CANCELLED = 1;
/** 持有鎖的執行緒的後繼執行緒被掛起 */
static final int SIGNAL = -1;
/** 條件佇列標識 */
static final int CONDITION = -2;
/**
* 共享鎖情況下，通知所有其他節點
*/
static final int PROPAGATE = -3;
/**
* waitStatus的取值如下:
* SIGNAL(-1): 當前節點的後繼節點應該被掛起
* CANCELLED(1): 當前節點被取消
* CONDITION(-2): 當前節點在條件佇列
* PROPAGATE(-3): 釋放共享鎖時需要通知所有節點
* 0: 初始值
*
*/
volatile int waitStatus;
/**
* 前驅節點
*/
volatile Node prev;
/**
* 後繼節點
*/
volatile Node next;
/**
* 節點對應的執行緒
*/
volatile Thread thread;
/**
* 在共享鎖的情況下，該節點的值為SHARED
* 在排他鎖的情況下，該節點的值為EXCLUSIVE
* 在條件佇列的情況下，連結的是下一個等待條件的執行緒
*/
Node nextWaiter;
}
其次，我們來看一下同步佇列的連結串列結構
接著，我們根據同步佇列的原理來分析以下acquire和release需要做哪些事情：
實現acquire功能需要做的事情
- 建立一個Node節點
node（該節點可能是排他鎖，也可以能是共享鎖） - 將
node新增到同步佇列尾部，如果同步佇列為空（初始情況下），需要先建立一個空的頭節點，然後再新增到佇列的尾部 - 如果
node的前驅節點是head，說明node是第一個節點，能夠獲取鎖，需要將head修改成node，釋放前驅節點的資源 - 如果
node的前驅節點不是head，說明獲取鎖失敗，需要檢測是否需要將node繫結的執行緒掛起，分以下幾種情況：- 如果
node的waitStatus已經被設定為SIGNAL表示需要被掛起 - 如果
node的waitStatus設定為CANCEL表示該節點已經被取消，需要被去掉，並修改node的prev，直到連結上一個有效的節點為止 - 否則將
node的waitStatus設定為SIGNAL，表示即將要被掛起
- 如果
- 如果需要將
node繫結的執行緒掛起，則讓出CPU，直到當前驅節點來喚起node才會開始繼續從步驟3開始執行
與acquire功能相關的程式碼
- acquire方法：獲取排他鎖
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
-
tryAcquire(arg)：對外提供的一個擴充套件方法，常用的鎖都要實現這個方法，具體實現與鎖相關 -
addWaiter(Node.EXCLUSIVE)： 建立一個排他鎖節點，並將該節點新增到同步佇列尾部，程式碼如下：
private Node addWaiter(Node mode) {
// 建立一個node，EXCLUSIVE型別
Node node = new Node(mode);
for (;;) {
// 獲取尾節點
Node oldTail = tail;
if (oldTail != null) {
// 設定即將成為尾節點的前驅
node.setPrevRelaxed(oldTail);
// CAS操作設定尾節點
if (compareAndSetTail(oldTail, node)) {
// 將新尾節點的前驅節點與新的尾節點關聯起來
oldTail.next = node;
// 返回新增的節點
// 這個節點現在不一定是尾節點，因為如果有多個執行緒呼叫這個方法時，
// 可能還有節點新增在這個節點後面
return node;
}
} else {
// 如果佇列為空，初始化頭節點
initializeSyncQueue();
}
}
}
acquireQueued：同步佇列中的節點獲取排他鎖
final boolean acquireQueued(final Node node, int arg) {
try {
// 執行緒是否中斷
boolean interrupted = false;
for (;;) {
// 獲取前驅節點
final Node p = node.predecessor();
// 如果前驅節點是頭節點，獲取鎖
if (p == head && tryAcquire(arg)) {
// 修改頭節點
setHead(node);
// 釋放頭節點的資源
p.next = null; // help GC
// 返回執行緒中斷的狀態
// 這也是該方法唯一的返回值
// 沒有獲取鎖的執行緒會一直執行該方法直到獲取鎖以後再返回
return interrupted;
}
// 獲取鎖失敗後是否需要將執行緒掛起
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt()) // 執行緒掛起並返回是否被中斷
interrupted = true;
}
} catch (Throwable t) {
// 取消該節點
cancelAcquire(node);
throw t;
}
}
shouldParkAfterFailedAcquire：檢測執行緒獲取鎖失敗以後是否需要被掛起
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
// 前驅節點的狀態
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* 狀態已經設定成SIGNAL，可以直接掛起該節點
*/
return true;
// 節點被取消
if (ws > 0) {
/*
* 找到pred第一個有效的前驅節點
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
// pred可能是一個新的節點，需要將pred的next重寫設定為node
pred.next = node;
} else {
/*
* CAS操作將pred節點的狀態設定為SIGNAL
*/
pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
}
// 只有當pred節點的waitStatus已經是SIGNAL狀態時，才可以安全的掛起執行緒
// 否則需要不能被掛起
return false;
}
parkAndCheckInterrupt：將當前執行緒掛起，並檢測當前執行緒是否中斷
private final boolean parkAndCheckInterrupt() {
// 執行緒掛起
LockSupport.park(this);
// 檢測執行緒是否中斷
return Thread.interrupted();
}
cancelAcquire：取消節點
private void cancelAcquire(Node node) {
// 如果節點為空，什麼都不做
if (node == null)
return;
// 釋放執行緒
node.thread = null;
// 從後往前過濾掉所有的被取消的節點
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
// 有效前驅節點的nex節點
Node predNext = pred.next;
// 將node設定為CANCELLED
node.waitStatus = Node.CANCELLED;
// 如果是尾節點，設定新的尾節點
if (node == tail && compareAndSetTail(node, pred)) {
// 將新的尾節點的後續設定為null
pred.compareAndSetNext(predNext, null);
} 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;
// 如果前驅節點的執行緒不為null並且waitStatus為SIGNAL
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && pred.compareAndSetWaitStatus(ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
// 將node設定成pred的後繼節點
if (next != null && next.waitStatus <= 0)
pred.compareAndSetNext(predNext, next);
} else {
// 喚起node節點的後繼節點
// 因為node節點已經釋放鎖了
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
unparkSuccessor：喚醒後繼節點
private void unparkSuccessor(Node node) {
/*
* 獲取node節點的waitStatus
*/
int ws = node.waitStatus;
// 用CSA操作將waitStatus設定成初始狀態
// 不管設定是否成功，都無所謂，因為該節點即將被銷燬
if (ws < 0)
node.compareAndSetWaitStatus(ws, 0);
/*
* 獲取node的後繼節點
*/
Node s = node.next;
// 如果後繼節點為null或者被取消，
// 通過從同步佇列的尾節點開始一直往前找到一個有效的後繼節點
if (s == null || s.waitStatus > 0) {
s = null;
for (Node p = tail; p != node && p != null; p = p.prev)
if (p.waitStatus <= 0)
s = p;
}
// 如果後繼節點不為空
if (s != null)
LockSupport.unpark(s.thread);// 喚醒後繼節點的執行緒
}
與acquire方法類似的還有acquireInterruptibly、tryAcquireNanos、acquireShared、acquireSharedInterruptibly和tryAcquireSharedNanos，我們都一一分析以下
- acquireInterruptibly方法：獲取可中斷的排他鎖
public final void acquireInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted()) // 如果執行緒中斷，直接返回
throw new InterruptedException();
if (!tryAcquire(arg))
doAcquireInterruptibly(arg); // 中斷式的獲取鎖
}
doAcquireInterruptibly：可中斷式的獲取鎖
private void doAcquireInterruptibly(int arg)
throws InterruptedException {
// 建立一個排他節點加入同步佇列
final Node node = addWaiter(Node.EXCLUSIVE);
try {
for (;;) {
// 獲取前驅節點
final Node p = node.predecessor();
// 如果前驅節點是頭節點，說明已經獲取的鎖
if (p == head && tryAcquire(arg)) {
// 修改頭節點
setHead(node);
p.next = null; // help GC
return;
}
// 如果沒有獲取鎖，檢測是否需要掛起
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException(); // 如果發現執行緒已經被中斷，需要丟擲異常
}
} catch (Throwable t) {
// 發生異常取消節點
cancelAcquire(node);
throw t;
}
}
- tryAcquireNanos方法：超時中斷獲取排他鎖
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException(); // 執行緒中斷直接返回
return tryAcquire(arg) ||
doAcquireNanos(arg, nanosTimeout); // 超時獲取排他鎖
}
doAcquireNanos：超時獲取排他鎖
private boolean doAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
// 如果超時直接返回
if (nanosTimeout <= 0L)
return false;
// 獲取超時時長
final long deadline = System.nanoTime() + nanosTimeout;
// 新增一個排他節點到同步佇列尾部
final Node node = addWaiter(Node.EXCLUSIVE);
try {
for (;;) {
// 獲取前驅節點
final Node p = node.predecessor();
// 已經獲取鎖
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
return true;
}
nanosTimeout = deadline - System.nanoTime();
// 如果超時了就取消
if (nanosTimeout <= 0L) {
cancelAcquire(node);
return false;
}
// 檢測節點是否需要被掛起
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > SPIN_FOR_TIMEOUT_THRESHOLD)
// 如果需要掛起，且超時時長大於SPIN_FOR_TIMEOUT_THRESHOLD
// 執行緒掛起nanosTimeout時間
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException();
}
} catch (Throwable t) {
// 發生異常取消節點
cancelAcquire(node);
throw t;
}
}
- acquireShared方法：獲取共享鎖
public final void acquireShared(int arg) {
// 對外提供的一個擴充套件方法，常用的鎖都要實現這個方法，
// 該方法的實現與鎖的用途有關
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg); // 獲取共享鎖
}
doAcquireShared：獲取共享鎖
private void doAcquireShared(int arg) {
// 新增一個共享節點到同步佇列尾部
final Node node = addWaiter(Node.SHARED);
try {
boolean interrupted = false;
for (;;) {
// 獲取前驅節點
final Node p = node.predecessor();
if (p == head) {
// 返回結果大於等於0表示獲取共享鎖
int r = tryAcquireShared(arg);
if (r >= 0) {
// 設定頭節點並廣播通知其他獲取共享鎖的節點
setHeadAndPropagate(node, r);
p.next = null; // help GC
// 如果執行緒被中斷，將該執行緒中斷
// 共享鎖會被多個執行緒獲取，如果需要中斷
// 所有獲取共享鎖的執行緒都要被中斷
if (interrupted)
selfInterrupt();
return;
}
}
// 檢測是否需要掛起
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt()) // 掛起並中斷
interrupted = true;
}
} catch (Throwable t) {
// 發生異常取消節點
cancelAcquire(node);
throw t;
}
}
setHeadAndPropagate：設定頭節點並廣播其他節點來獲取鎖
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // 記錄舊的頭節點
setHead(node);// 設定新的頭節點
/*
* 如果頭節點為null或者是不是取消狀態，嘗試喚醒後繼節點
*/
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
// node節點的next是SHARED，即共享鎖
if (s == null || s.isShared())
// 喚起獲取共享鎖的執行緒
doReleaseShared();
}
}
doReleaseShared：喚醒等待共享鎖的節點
private void doReleaseShared() {
/*
* 喚醒時是從頭節點開始先喚醒第一個共享節點，
* 第一個共享節點被喚醒後會在doAcquireShared方法裡繼續執行（之前就是在這個方法裡被掛起的）
* 第一個共享節點如果獲取鎖會呼叫setHeadAndPropagate方法修改頭節點，然後再呼叫doReleaseShared方法
* 喚醒第二個共享節點，以此類推，最後把所有的共享節點都喚醒
*/
for (;;) {
Node h = head;
if (h != null && h != tail) {
// 獲取頭節點的狀態
int ws = h.waitStatus;
// 如果頭節點是SIGNAL，需要將狀態設定為0，表示已經即將被喚醒
if (ws == Node.SIGNAL) {
if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))
continue; // 如果失敗了說明有其他執行緒在修改頭節點，需要繼續重試
unparkSuccessor(h); // 喚醒頭節點的後繼節點
}
else if (ws == 0 &&
!h.compareAndSetWaitStatus(0, Node.PROPAGATE))
continue; // 將頭節點狀態從0設定成PROPAGATE，如果失敗了繼續，因為也有其他獲取共享鎖的執行緒在更改頭節點
}
// 如果頭節點未改變（因為沒有後繼節點需要等待共享鎖），跳出迴圈
if (h == head)
break;
}
}
selfInterrupt：中斷當前執行緒
static void selfInterrupt() {
Thread.currentThread().interrupt();
}
- acquireSharedInterruptibly方法：可中斷的獲取共享鎖
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException(); // 如果執行緒被中斷丟擲異常
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg); // 可中斷的方式獲取共享鎖
}
doAcquireSharedInterruptibly：可中斷的方式後去共享鎖
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
// 新增共享鎖節點到同步佇列尾部
final Node node = addWaiter(Node.SHARED);
try {
for (;;) {
// 獲取前驅節點
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
// 獲取共享鎖以後修改頭節點，通知其他等待共享鎖的節點
setHeadAndPropagate(node, r);
p.next = null; // help GC
return;
}
}
// 執行緒獲取共享鎖失敗後需要掛起，並且發現執行緒被中斷，所以丟擲異常
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} catch (Throwable t) {
// 發生異常取消節點
cancelAcquire(node);
throw t;
}
}
- tryAcquireSharedNanos方法：超時中斷獲取共享鎖
public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted()) // 執行緒如果中斷了，直接丟擲異常
throw new InterruptedException();
return tryAcquireShared(arg) >= 0 ||
doAcquireSharedNanos(arg, nanosTimeout); // 超時獲取共享鎖
}
doAcquireSharedNanos：超時的方式獲取中斷鎖
private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
throws InterruptedException {
// 超時直接返回
if (nanosTimeout <= 0L)
return false;
final long deadline = System.nanoTime() + nanosTimeout;
// 新增共享節點到同步佇列尾部
final Node node = addWaiter(Node.SHARED);
try {
for (;;) {
// 獲取前驅節點
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
// 獲取鎖，修改頭節點，通知所有其他等待共享鎖的節點
setHeadAndPropagate(node, r);
p.next = null; // help GC
return true;
}
}
nanosTimeout = deadline - System.nanoTime();
if (nanosTimeout <= 0L) {
// 超時取消節點
cancelAcquire(node);
return false;
}
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > SPIN_FOR_TIMEOUT_THRESHOLD)
// 如果需要掛起，且超時時長大於SPIN_FOR_TIMEOUT_THRESHOLD
// 執行緒掛起nanosTimeout時間
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException(); // 中斷了丟擲異常
}
} catch (Throwable t) {
// 發生異常取消節點
cancelAcquire(node);
throw t;
}
}
實現release功能需要做的事情
- 釋放當前獲取鎖的執行緒持有的資源
- 喚醒有效的一個後繼節點
與release功能相關的程式碼
- release方法：釋放排他鎖
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
// 頭節點不能是一箇中間態
if (h != null && h.waitStatus != 0)
// 喚醒後繼節點
unparkSuccessor(h);
return true;
}
return false;
}
- release方法：釋放共享鎖
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
// 釋放共享鎖，從頭節點開始一個一個的釋放
// 如果存在多個共享節點在同步佇列時，doReleaseShared方式其實是遞迴呼叫
doReleaseShared();
return true;
}
return false;
}
至此，將所有獲取鎖和釋放鎖的方法相關的原始碼全部分析完
條件佇列的實現
我們來看一下條件佇列的連結串列結構
實現await功能需要做的事情
- 建立一個
CONDITION型別的節點，將該節點新增到條件佇列 - 釋放已經獲取的鎖（因為只有當前執行緒先獲取了鎖才可能再呼叫
Condition.await()方法） - 如果無法獲取鎖，執行緒掛起
與await功能相關的程式碼
- await方法：等待條件
public final void await() throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException(); // 如果執行緒中斷，直接丟擲異常
// 建立一個CONDITION型別的節點，將該節點新增到條件佇列尾部
Node node = addConditionWaiter();
// 釋放鎖
// 在呼叫await方法之前都會呼叫lock方法，這個時候已經獲取鎖了
// 有時候鎖還是可重入的，所以需要將所有的資源都釋放掉
int savedState = fullyRelease(node);
int interruptMode = 0;
// 如果節點不再同步佇列，全部都要掛起
while (!isOnSyncQueue(node)) {
LockSupport.park(this);
// 如果在等待期間發生過中斷（不管是呼叫signal之前還是之後），直接退出
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
// 讓執行緒嘗試去獲取鎖，如果無法獲取鎖就掛起
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
// 清除所有在條件佇列中是取消狀態的節點
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
// 發生中斷，上報中斷情況
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
addConditionWaiter：在條件佇列中新增一個節點
private Node addConditionWaiter() {
Node t = lastWaiter;
// 清除條件佇列中無效的節點
if (t != null && t.waitStatus != Node.CONDITION) {
unlinkCancelledWaiters();
t = lastWaiter;
}
// 建立一個節點
Node node = new Node(Node.CONDITION);
// 新增到條件佇列尾部
if (t == null)
firstWaiter = node;
else
t.nextWaiter = node;
lastWaiter = node;
return node;
}
unlinkCancelledWaiters：清除在條件佇列中被取消的節點
private void unlinkCancelledWaiters() {
Node t = firstWaiter;
Node trail = null;
// 遍歷條件佇列將所有不是CONDITION狀態的節點全部清除掉
// 這些節點都是取消狀態的節點
while (t != null) {
Node next = t.nextWaiter;
if (t.waitStatus != Node.CONDITION) {
t.nextWaiter = null;
if (trail == null)
firstWaiter = next;
else
trail.nextWaiter = next;
if (next == null)
lastWaiter = trail;
}
else
trail = t;
t = next;
}
}
fullyRelease：釋放執行緒持有的所有鎖資源
final int fullyRelease(Node node) {
try {
int savedState = getState();
// 釋放所有的資源
// 如果是可重入鎖，savedState就是重入的次數
if (release(savedState))
return savedState;
throw new IllegalMonitorStateException();
} catch (Throwable t) {
// 發生異常就取消該節點
node.waitStatus = Node.CANCELLED;
throw t;
}
}
isOnSyncQueue：判斷節點是否在同步佇列
final boolean isOnSyncQueue(Node node) {
// waitStatus是CONDITION或者node沒有前驅節點，說明node不在同步佇列
if (node.waitStatus == Node.CONDITION || node.prev == null)
return false;
if (node.next != null) // 有後繼節點一定在同步佇列
return true;
/*
* 在同步佇列中查詢node，看是否在同步佇列中
*/
return findNodeFromTail(node);
}
findNodeFromTail：在同步佇列中查詢節點
private boolean findNodeFromTail(Node node) {
// 從尾節點開始查詢
for (Node p = tail;;) {
if (p == node) // 找到了
return true;
if (p == null) // 找到頭了還沒找到
return false;
p = p.prev;
}
}
checkInterruptWhileWaiting：檢測中斷的情況
private int checkInterruptWhileWaiting(Node node) {
// 沒有發生中斷返回0
// 呼叫signal之前發生中斷返回THROW_IE
// 呼叫signal之後發生中斷返回REINTERRUPT
return Thread.interrupted() ?
(transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
0;
}
transferAfterCancelledWait：清除在條件佇列中被取消的節點
// 只有執行緒處於中斷狀態，才會呼叫此方法
// 如果需要的話，將這個已經取消等待的節點轉移到阻塞佇列
// 返回 true，如果此執行緒在 signal 之前被取消，否則返回false
final boolean transferAfterCancelledWait(Node node) {
// 用 CAS 將節點狀態設定為 0
// 如果這步 CAS 成功，說明是 signal 方法之前發生的中斷，
// 因為如果 signal 先發生的話，signal 中會將 waitStatus 設定為 0
if (node.compareAndSetWaitStatus(Node.CONDITION, 0)) {
enq(node); // 將節點放入阻塞佇列
return true;
}
// 到這裡是因為 CAS 失敗，肯定是因為 signal 方法已經將 waitStatus 設定為了 0
// signal 方法會將節點轉移到阻塞佇列，但是可能還沒完成，這邊自旋等待其完成
// 當然，這種事情還是比較少的吧：signal 呼叫之後，沒完成轉移之前，發生了中斷
while (!isOnSyncQueue(node))
Thread.yield();
return false;
}
enq：把節點新增到同步佇列
private Node enq(Node node) {
// 無限迴圈，將節點新增到同步佇列尾部
for (;;) {
Node oldTail = tail;
if (oldTail != null) {
node.setPrevRelaxed(oldTail);
if (compareAndSetTail(oldTail, node)) {
oldTail.next = node;
return oldTail;
}
} else {
// 如果同步佇列為空，初始化
initializeSyncQueue();
}
}
}
reportInterruptAfterWait：中斷處理
private void reportInterruptAfterWait(int interruptMode)
throws InterruptedException {
// 如果是THROW_IE狀態，拋異常
if (interruptMode == THROW_IE)
throw new InterruptedException();
else if (interruptMode == REINTERRUPT) // 再次中斷，因為中斷狀態被使用過一次
selfInterrupt();
}
awaitNanos、awaitUntil和await(long time, TimeUnit unit)這幾個方法的整體邏輯是一樣的，就不再分析了
實現signal功能需要做的事情
- 將條件佇列中的節點加入同步佇列
- 喚醒執行緒
與signal功能相關的程式碼
- signal方法：喚醒等待條件的節點
public final void signal() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
// 獲取條件佇列中的第一個節點
Node first = firstWaiter;
if (first != null)
// 喚醒等待條件的節點
doSignal(first);
}
doSignal：喚醒等待條件的節點
private void doSignal(Node first) {
do {
// 去掉無效的節點
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
first.nextWaiter = null;
} while (!transferForSignal(first) && // 將節點轉移到同步佇列
(first = firstWaiter) != null);
}
transferForSignal：將節點轉移到同步佇列
final boolean transferForSignal(Node node) {
/*
* 取消的節點不需要轉移
*/
if (!node.compareAndSetWaitStatus(Node.CONDITION, 0))
return false;
/*
* 將節點加入同步佇列尾部
*/
Node p = enq(node);
int ws = p.waitStatus;
// ws > 0 說明 node 在阻塞佇列中的前驅節點取消了等待鎖，直接喚醒 node 對應的執行緒
// 如果 ws <= 0, 那麼 compareAndSetWaitStatus 將會被呼叫
// 節點入隊後，需要把前驅節點的狀態設為SIGNAL
if (ws > 0 || !p.compareAndSetWaitStatus(ws, Node.SIGNAL))
// 如果前驅節點取消或者 CAS 失敗，會進到這裡喚醒執行緒
LockSupport.unpark(node.thread);
return true;
}
- signalAlll方法：喚醒所有等待條件的節點
public final void signalAll() {
// 如果是當前執行緒
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
// 喚醒所有等待條件的節點
doSignalAll(first);
}
doSignalAll：喚醒所有等待條件的節點
// 將所有的節點都轉移到同步佇列
private void doSignalAll(Node first) {
lastWaiter = firstWaiter = null;
do {
Node next = first.nextWaiter;
first.nextWaiter = null;
transferForSignal(first);
first = next;
} while (first != null);
}
現在將與AQS相關的核心程式碼都整理了一遍，裡面如果有描述不清晰或者不準確的地方希望大家可以幫忙指出！