0 簡介
佇列同步器AbstractQueuedSynchronizer（後面簡稱AQS）是實現鎖和有關同步器的一個基礎框架。
在JDK5中，Doug Lea在併發包中加入了大量的同步工具，例如重入鎖（ReentrantLock）、讀寫鎖（ReentrantReadWriteLock）、訊號量（Semaphore）、CountDownLatch等，都是基於AQS的。
其內部通過一個被標識為volatile的名為state的變數來控制多個執行緒之間的同步狀態。多個執行緒之間可以通過AQS來獨佔式或共享式的搶佔資源。
基於AQS，可以很方便的實現Java中不具備的功能。
例如，在鎖這個問題上，Java中提供的是synchronized關鍵字，用這個關鍵字可以很方便的實現多個執行緒之間的同步。但這個關鍵字也有很多缺陷，比如：
- 他不支援超時的獲取鎖，一個執行緒一旦沒有從synchronized上獲取鎖，就會卡在這裡，沒有機會逃脫。所以通常由synchronized造成的死鎖是無解的。
- 不可響應中斷。
- 不能嘗試獲取鎖。如果嘗試獲取時沒獲取到，立刻返回，synchronized不具備這一特性。
而ReentrantLock基於AQS將上述幾點都做到了。
1 核心結構
從AbstractQueuedSynchronizer的名字可以看出，AQS中一定是基於佇列實現的（Queue）。在AQS內部，是通過連結串列實現的佇列。連結串列的每個元素是其內部類Node的一個實現。然後AQS通過例項變數head指向佇列的頭，通過例項變數tail指向佇列的尾。
其原始碼定義如下：
/**
* Head of the wait queue, lazily initialized. Except for
* initialization, it is modified only via method setHead. Note:
* If head exists, its waitStatus is guaranteed not to be
* CANCELLED.
*/
private transient volatile Node head;
/**
* Tail of the wait queue, lazily initialized. Modified only via
* method enq to add new wait node.
*/
private transient volatile Node tail;
/**
* The synchronization state.
*/
private volatile int state;
static final class Node {
/** 標識為共享式 */
static final Node SHARED = new Node();
/** 標識為獨佔式 */
static final Node EXCLUSIVE = null;
/** 同步佇列中等待的執行緒等待超時或被中斷，需要從等待佇列中取消等待，進入該狀態的節點狀態將不再變化 */
static final int CANCELLED = 1;
/** 當前節點的後繼節點處於等待狀態，且當前節點釋放了同步狀態，需要通過unpark喚醒後繼節點，讓其繼續執行 */
static final int SIGNAL = -1;
/** 當前節點等待在某一Condition上，當其他執行緒呼叫這個Conditino的signal方法後，該節點將從等待佇列恢復到同步佇列中，使其有機會獲取同步狀態 */
static final int CONDITION = -2;
/** 表示下一次共享式同步狀態獲取狀態將無條件的傳播下去 */
static final int PROPAGATE = -3;
/* 當前節點的等待狀態，取值為上述幾個常量之一，另外，值為0表示初始狀態 */
volatile int waitStatus;
/* 前驅節點 */
volatile Node prev;
/* 後繼節點 */
volatile Node next;
/* 等待獲取同步狀態的執行緒 */
volatile Thread thread;
/* 等待佇列中的後繼節點 */
Node nextWaiter;
// ...
}
複製程式碼當執行緒通過AQS獲取同步狀態時，AQS會將當前執行緒封裝到Node內部，併入隊。所以在多個執行緒併發獲取同步狀態時，AQS內部會持有如下結構的佇列：
下文會基於這個佇列模型，說明一下執行緒在AQS中獲取同步狀態時的原理。
2 實現原理
從AQS的名字可以看出來，作者是希望AQS作為一個基類來向外提供服務的（以Abstract標識）。所以通常AQS是以繼承的方式使用的。
AQS提供了幾個模板方法供實現類自己實現定製功能。
這幾個方法是：
- boolean tryAcquire(int arg)：獨佔式的獲取同步狀態，通常通過以CAS的方式修改state的值來實現特定功能。
- boolean tryRelease(int arg)：獨佔式的釋放同步狀態，通常也是修改state的值。
- int tryAcquireShared(int arg)：共享式的獲取同步狀態，返回值>=0表示成功，否則失敗。
- boolean tryReleaseShared(int arg)：共享式的釋放同步狀態，同樣通過修改state值來實現。
- boolean isHeldExclusively()：表示AQS是否被當前執行緒獨佔。
這幾個方法的預設實現都會丟擲UnsupportedOperationException異常。
目前我們不用關心這幾個方法，只要明白其內部是通過控制state的值來管理同步狀態即可。
2.1 同步狀態的獲取
通常，實現類會優先嚐試修改state的值，來獲取同步狀態。例如，如果某個執行緒成功的將state的值從0修改為1，表示成功的獲取了同步狀態。 這個修改的過程是通過CAS完成的，所以可以保證執行緒安全。
反之，如果修改state失敗，則會將當前執行緒加入到AQS的佇列中，並阻塞執行緒。
AQS內部提供了三個方法來修改state的狀態，其原始碼如下：
/**
* Returns the current value of synchronization state.
* This operation has memory semantics of a {@code volatile} read.
* @return current state value
*/
protected final int getState() {
return state;
}
/**
* Sets the value of synchronization state.
* This operation has memory semantics of a {@code volatile} write.
* @param newState the new state value
*/
protected final void setState(int newState) {
state = newState;
}
/**
* Atomically sets synchronization state to the given updated
* value if the current state value equals the expected value.
* This operation has memory semantics of a {@code volatile} read
* and write.
*
* @param expect the expected value
* @param update the new value
* @return {@code true} if successful. False return indicates that the actual
* value was not equal to the expected value.
*/
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
複製程式碼2.2同步佇列
如上文所述，AQS內部實際上是一個FIFO的雙端佇列，當執行緒獲取同步狀態失敗時，就會構建一個Node並新增到佇列尾部（此過程是執行緒安全的，CAS實現），並阻塞當前執行緒（通過LockSupport.park()方法）； 當釋放同步狀態時，AQS會先判斷head節點是否為null，如果不是null，說明有等待同步狀態的執行緒，就會嘗試喚醒head節點，使其重新競爭同步狀態。
2.3 獨佔式同步狀態的獲取
獨佔式的意思就是說同一時間只能有一個執行緒獲得同步狀態。
AQS會先嚐試呼叫實現類的tryAcquire方法獲取同步狀態，如果獲取失敗，會嘗試將其封裝為Node節點新增到同步佇列尾部。
獨佔式同步狀態的獲取通過AQS的acquire方法實現。其原始碼如下：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
複製程式碼這個方法會先嚐試獲取一次同步狀態（tryAcquire），如果獲取失敗，會通過addWaiter方法將當前執行緒加入到同步佇列。 並在acquireQueued方法中將當前執行緒阻塞（LockSupport.park()），並進入自旋狀態，以獲取同步狀態。
下面具體看一下他是如何構建Node並將其新增到隊尾的。 首先是addWaiter：
/**
* Creates and enqueues node for current thread and given mode.
*
* @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
* @return the new node
*/
private Node addWaiter(Node mode) {
// mode = Node.EXCLUSIVE，表示是獨佔模式
Node node = new Node(Thread.currentThread(), mode);
// 先快速的通過CAS的方式將Node新增到隊尾，如果失敗，再進入enq方法通過無限迴圈新增
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
/**
* Inserts node into queue, initializing if necessary. See picture above.
* @param node the node to insert
* @return node's predecessor
*/
private Node enq(final Node node) {
// 無限迴圈的將node新增到隊尾，保證能新增成功
/*
注意：如果是首次向佇列中新增Node，那麼調addWaiter方法時，tail還是null，所以addWaiter方法不會設定成功，會直接進入這個方法
進入這個方法後，由於tail仍然是null，所以會走到第一個if裡面，這是會建立一個空的Node出來作為頭結點
然後再次迴圈，此時tail不是null了，會進入else的程式碼中，這時，才會將需要add的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;
}
}
}
}
複製程式碼再看下acquireQueued方法：
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
// 進入自旋，不斷的獲取同步狀態
for (;;) {
// 獲取node在佇列中的前驅節點
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
// 如果成功進入到這塊程式碼，說明成功的獲取了同步狀態
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 獲取不成功，呼叫LockSupport.park()方法將當前執行緒阻塞
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
複製程式碼shouldParkAfterFailedAcquire方法使用者判斷是否需要阻塞當前執行緒，方法內會操作當前隊尾節點的前驅節點的waitStatus，並依據waitStatus判斷是否需要park。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL) // Node.SIGNAL == -1
/*
* 表明當前節點需要其他執行緒的喚醒才能繼續執行，此時可以安全的park。
*/
return true;
if (ws > 0) {
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* 如果一個節點是初始狀態，即waitStatus=0時，
* 將前驅節點的waitStatus設定為-1，表明其需要別的執行緒喚醒才能繼續執行
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
複製程式碼當shouldParkAfterFailedAcquire方法判斷當前節點需要被park時，會呼叫parkAndCheckInterrupt將其阻塞：
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
複製程式碼2.4 獨佔式同步狀態的釋放
獨佔式的同步狀態釋放，在AQS中是通過release()方法實現的。此方法原始碼如下：
public final boolean release(int arg) {
// 嘗試呼叫實現類的tryRelease方法來修改同步狀態（state）
if (tryRelease(arg)) {
Node h = head;
/*
1.如果head節點是null，表示沒有其他執行緒競爭同步狀態，直接返回釋放成功
2.如果head節點不是null，表明有競爭。通過unparkSuccessor方法，通過unpark方法喚醒head節點的next節點。使其重新嘗試競爭同步狀態。
*/
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
複製程式碼unparkSuccessor方法會喚醒head節點的next節點，使其可以重新競爭同步狀態：
private void unparkSuccessor(Node node) {
/*
* 如果waitStatus的值是負數，例如：-1（等待signal）
* 則將其值還原為0
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* 獲取頭結點的next節點，如果非空，則unpark他
*/
Node s = node.next;
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);
}
複製程式碼2.5 獨佔式同步狀態獲取與釋放-圖示
下面會通過畫圖方式展示一下原始碼中的過程，首先我們假設tryAcquire的實現如下：
boolean tryAcquire(int acquires) {
return compareAndSetState(0, acquires);
}
複製程式碼引數acquires固定傳1，意為：通過CAS，如果成功將state的值從0修改為1，表示獲取同步狀態成功，否則失敗，需要加入同步佇列。
假設tryRelease的實現如下：
boolean tryRelease(int releases) {
int c = getState() - releases;
if (c == 0) {
setState(c);
return true;
}
return false;
}
複製程式碼引數releases固定傳1，意為：如果當前state-1=0，視為釋放成功，其他執行緒可競爭同步狀態。
假設有三個執行緒併發獲取同步狀態，標識為t1、t2、t3，三個執行緒同時通過acquire方法修改state值。
假設t1修改成功，t2和t3修改失敗。
t1修改成功之後，將state值變為1，並直接返回。此時head和tail都是空，所以同步佇列也是空的。此時同步佇列狀態如下：
t2執行緒競爭同步狀態失敗，加入到同步佇列中：
t3執行緒競爭同步狀態失敗，加入到同步佇列中：
t1執行緒執行完畢，釋放資源。 先將state還原為0，再unpark頭結點的next節點（t2節點），使之重獲同步狀態的競爭資格。
假設t2被喚醒後成功的獲取到了同步狀態（即呼叫tryAcquire方法併成功將state設定為1），t2會將自己所在的Node設定為head節點，並將原head節點的next設定為null（有助於GC）
t2執行完成，釋放同步狀態，將state設定為0，同時喚醒t3，使之再次具備競爭資格
假設t3成功獲取同步狀態，此時t3將自己所在的Node設定為head節點，並將之前的head節點的next設定為null（即將t2的next設定為null）
t3執行完畢，釋放同步狀態，將state設定為0。由於此時其waitStatus等於0，表示已經沒有後繼節點需要unpark，直接返回釋放成功
最後的t3節點並沒有被清空，因為他可以用作下一次同步狀態競爭的head節點。
2.6 超時獲取同步狀態
tryAcquireNanos方法實現了這個功能。他與上面描述的獲取同步狀態的過程大致相同，只不過是加上了時間的判斷。 也就是說，每次自旋獲取同步狀態時，先判斷當前時間是否超過了指定的超時時間，如果超時直接返回獲取失敗。
下面來看下原始碼，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);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return true;
}
// 判斷，如果超時，直接返回獲取失敗
nanosTimeout = deadline - System.nanoTime();
if (nanosTimeout <= 0L)
return false;
// 沒超時的話，判斷剩餘時間是否大於1000納秒，如果大於才park當前執行緒
// 否則，不park，直接進入下一次自旋獲取，因為這個時間足夠小了，可能已經超出了一次系統呼叫的時間
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold) // spinForTimeoutThreshold = 1000
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
複製程式碼3 參考
- Java併發程式設計的藝術 方騰飛，魏鵬，程曉明