沒看過AQS源碼，別說精通Java并發(fā)編程
作者：一燈架構(gòu)
AQS的源碼邏輯比較復(fù)雜，很多開發(fā)者看見就頭疼，邏輯眾多，無法梳理清楚。原因就是開發(fā)者梳理源碼的步驟出錯(cuò)了，剛開始就看AQS的加鎖、釋放鎖邏輯，陷入細(xì)節(jié)中不能自拔。
前言
AQS 全稱 AbstractQueuedSynchronizer（抽象隊(duì)列同步器），旨在作為創(chuàng)建鎖和其他同步機(jī)制的基礎(chǔ)，常見的同步鎖 ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier等都是基于 AQS 實(shí)現(xiàn)的。所以只有了解了AQS的實(shí)現(xiàn)原理，才能更好學(xué)習(xí)使用其他同步鎖。
AQS的源碼邏輯比較復(fù)雜，很多開發(fā)者看見就頭疼，邏輯眾多，無法梳理清楚。原因就是開發(fā)者梳理源碼的步驟出錯(cuò)了，剛開始就看AQS的加鎖、釋放鎖邏輯，陷入細(xì)節(jié)中不能自拔。正確的做法是，先整體后局部，先框架后細(xì)節(jié)。下面就帶著大家一下分析AQS源碼，保證清晰易懂。
AQS加鎖流程
為什么一上來先看AQS的加鎖流程，先要理解AQS的框架設(shè)計(jì)，才能去看具體的源碼。
問個(gè)問題，如果讓你設(shè)計(jì)一個(gè)同步鎖，你會(huì)怎么設(shè)計(jì)？
肯定先要梳理一下需求，需求沒有梳理清楚，就別談開發(fā)了。
我理解的設(shè)計(jì)一個(gè)同步鎖，需要滿足以下需求：
- 當(dāng)多個(gè)線程競(jìng)爭(zhēng)同一個(gè)臨界資源的時(shí)候，只有一個(gè)線程可以獲取到臨界資源，其他線程只能等待。所以這里我們需要一個(gè)狀態(tài)state用來記錄臨界資源是否被加鎖和加鎖的次數(shù)，還需要記錄一下這個(gè)資源是被哪個(gè)線程持有，字段名叫做exclusiveOwnerThread。還需要一個(gè)隊(duì)列，用來存儲(chǔ)等待獲取資源的線程，這個(gè)隊(duì)列我們叫做同步隊(duì)列。
- 持有資源的線程可以主動(dòng)掛起自己（調(diào)用await()方法），并且釋放鎖，然后等待被其他線程喚醒。所以這里需要一個(gè)隊(duì)列存儲(chǔ)需要被喚醒的線程，這個(gè)隊(duì)列我們叫做條件隊(duì)列。
- 在條件隊(duì)列中線程被喚醒后，并不能立即獲取到鎖，還需要跟同步隊(duì)列中線程一起競(jìng)爭(zhēng)鎖。所以在條件隊(duì)列中被喚醒的線程，需要轉(zhuǎn)移到同步隊(duì)列。
至此，我們梳理清楚了AQS的加鎖需求，而實(shí)際上AQS的加鎖流程跟上面的需求完全一致，下面用一張圖來表示。
圖片
AQS的數(shù)據(jù)結(jié)構(gòu)
看一下AQS內(nèi)部的架構(gòu)設(shè)計(jì)和包含的屬性。
// AQS繼承自AbstractOwnableSynchronizer，為了記錄哪個(gè)線程占用鎖
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
// 同步狀態(tài)，0表示無鎖，每次加鎖+1，釋放鎖-1
private volatile int state;
// 同步隊(duì)列的頭尾節(jié)點(diǎn)
private transient volatile Node head;
private transient volatile Node tail;
// Node節(jié)點(diǎn)，用來包裝線程，放到隊(duì)列中
static final class Node {
// 節(jié)點(diǎn)中的線程
volatile Thread thread;
// 節(jié)點(diǎn)狀態(tài)
volatile int waitStatus;
// 同步隊(duì)列的前驅(qū)節(jié)點(diǎn)和后繼節(jié)點(diǎn)
volatile Node prev;
volatile Node next;
// 條件隊(duì)列的后繼節(jié)點(diǎn)或者同步隊(duì)列的共享/排他模式
Node nextWaiter;
}
// 條件隊(duì)列
public class ConditionObject implements Condition {
// 條件隊(duì)列的頭尾節(jié)點(diǎn)
private transient Node firstWaiter;
private transient Node lastWaiter;
}
}首先AQS繼承自AbstractOwnableSynchronizer，其實(shí)是為了記錄哪個(gè)線程正在占用鎖。
public abstract class AbstractOwnableSynchronizer {
// 正在占用鎖的線程
private transient Thread exclusiveOwnerThread;
// 設(shè)置占用鎖的線程
protected final void setExclusiveOwnerThread(Thread thread) {
exclusiveOwnerThread = thread;
}
protected final Thread getExclusiveOwnerThread() {
return exclusiveOwnerThread;
}
}無論是同步隊(duì)列還是條件隊(duì)列中線程都需要包裝成Node節(jié)點(diǎn)。
圖片
同步隊(duì)列：是帶有頭尾節(jié)點(diǎn)的雙鏈表，由Node節(jié)點(diǎn)組成，使用prev和next組成雙向鏈表，nextWaiter只用來表示是共享模式還是排他模式。條件隊(duì)列：是帶有頭尾節(jié)點(diǎn)的單鏈表。同樣由Node節(jié)點(diǎn)組成，沒有使用到Node中prev和next屬性，而是使用nextWaiter組成單鏈表。 這個(gè)復(fù)用對(duì)象的設(shè)計(jì)思想值得我們學(xué)習(xí)。 同步隊(duì)列head節(jié)點(diǎn)是個(gè)啞節(jié)點(diǎn)，里面并沒有存儲(chǔ)線程對(duì)象。當(dāng)然head節(jié)點(diǎn)也可以看成是給當(dāng)前持有鎖的線程使用的。 Node節(jié)點(diǎn)的節(jié)點(diǎn)狀態(tài)（waitStatus）共有5種：
- 1 cancelled：表示節(jié)點(diǎn)的線程已經(jīng)被取消
- 0 初始化：Node節(jié)點(diǎn)的默認(rèn)值
- -1 signal: 表示節(jié)點(diǎn)線程在釋放鎖后要喚醒同步隊(duì)列中的后繼節(jié)點(diǎn)
- -2 condition: 當(dāng)前節(jié)點(diǎn)在條件隊(duì)列中
- -3 propagate: 釋放共享資源的時(shí)候會(huì)向后傳播釋放其他共享節(jié)點(diǎn)（用于共享模式）
節(jié)點(diǎn)狀態(tài)（waitStatus）流轉(zhuǎn)過程如下：
圖片
AQS方法概覽
AQS支持排他模式和共享模式兩種訪問資源的模式（排他模式又叫獨(dú)占模式）。 排他模式的方法：
// 加鎖
acquire(int arg);
// 加可中斷的鎖
acquireInterruptibly(int arg);
// 加鎖，帶超時(shí)時(shí)間（如果指定時(shí)間內(nèi)加鎖不成功，就返回false）
tryAcquireNanos(int arg, long nanosTimeout);
// 釋放鎖
release(int arg);共享模式的方法：
// 加鎖
acquireShared(int arg);
// 加可中斷的鎖
acquireSharedInterruptibly(int arg);
// 加鎖，帶超時(shí)時(shí)間（如果指定時(shí)間內(nèi)加鎖不成功，就返回false）
tryAcquireSharedNanos(int arg, long nanosTimeout);
// 釋放鎖
releaseShared(int arg);排他模式和共享模式的方法并沒有實(shí)現(xiàn)具體的加鎖、釋放鎖邏輯，AQS中只是定義了加鎖、釋放鎖的抽象方法。 留給子類實(shí)現(xiàn)的抽象方法：
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
// 加排他鎖
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();
}
// 判斷是否是當(dāng)前線程正在持有鎖
protected boolean isHeldExclusively() {
throw new UnsupportedOperationException();
}
}這里就用到了設(shè)計(jì)模式中的模板模式，父類AQS定義了加鎖、釋放鎖的流程，子類ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier負(fù)責(zé)實(shí)現(xiàn)具體的加鎖、釋放鎖邏輯。 這不是個(gè)面試知識(shí)點(diǎn)嗎？ 面試官再問你，你看過哪些框架源碼使用到了設(shè)計(jì)模式？ 你就可以回答AQS源碼中用到了模板模式，巴拉巴拉，妥妥的加分項(xiàng)！
條件隊(duì)列的方法
條件隊(duì)列中常用的方法如下：
// 等待方法，并釋放鎖
public final void await() throws InterruptedException {
……
}
// 等待指定時(shí)間
public final boolean await(long time, TimeUnit unit) throws InterruptedException {
……
}
// 喚醒條件隊(duì)列中的單個(gè)線程
public final void signal() {
……
}
// 喚醒條件隊(duì)列中的所有線程
public final void signalAll() {
……
}排它鎖
1. 加鎖
整個(gè)加鎖流程如下：
圖片
再看一下加鎖方法的源碼：
// 加鎖方法，傳參是1，表示加鎖一次
public final void acquire(int arg) {
// 1. 首先嘗試獲取鎖，如果獲取成功，則設(shè)置state+1，exclusiveOwnerThread=currentThread（留給子類實(shí)現(xiàn)）
if (!tryAcquire(arg) &&
// 2. 如果沒有獲取成功，把線程組裝成Node節(jié)點(diǎn)，追加到同步隊(duì)列末尾
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
// 3. 加入同步隊(duì)列后，將自己掛起
selfInterrupt();
}
}再看一下addWaiter()方法源碼，作用就是把線程組裝成Node節(jié)點(diǎn)，追加到同步隊(duì)列末尾。
// 追加到同步隊(duì)列末尾，傳參mode表示是共享模式or排他模式
private Node addWaiter(Node mode) {
// 1. 組裝成Node節(jié)點(diǎn)
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
if (pred != null) {
node.prev = pred;
// 2. 在多線程競(jìng)爭(zhēng)不激烈的情況下，通過CAS方法追加到同步隊(duì)列末尾
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 3. 在多線程競(jìng)爭(zhēng)激烈的情況下，使用死循環(huán)保證追加到同步隊(duì)列末尾
enq(node);
return node;
}
// 通過死循環(huán)的方式，追加到同步隊(duì)列末尾
private Node enq(final Node node) {
for (; ; ) {
Node t = tail;
if (t == null) {
// 如果同步隊(duì)列為空，先初始化頭節(jié)點(diǎn)（頭節(jié)點(diǎn)是空節(jié)點(diǎn)）
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 再使用CAS追加到同步隊(duì)列末尾
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
// 創(chuàng)建Node節(jié)點(diǎn)，傳參thread表示當(dāng)前線程，mode表示共享模式or排他模式
Node(Thread thread, Node mode) {
this.thread = thread;
this.nextWaiter = mode;
}再看一下addWaiter()方法外層的acquireQueued()方法，作用就是：
- 在追加到同步隊(duì)列末尾后，再判斷一下前驅(qū)節(jié)點(diǎn)是不是頭節(jié)點(diǎn)。如果是，說明是第一個(gè)加入同步隊(duì)列的，就再去嘗試獲取鎖。如果獲取鎖成功，就把自己設(shè)置成頭節(jié)點(diǎn)。
- 如果前驅(qū)節(jié)點(diǎn)不是頭節(jié)點(diǎn)，或者獲取鎖失敗，就逆序遍歷同步隊(duì)列，找到可以將自己?jiǎn)拘训墓?jié)點(diǎn)。
- 最后才放心地將自己掛起
// 追加到同步隊(duì)列末尾后，再次嘗試獲取鎖
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (; ; ) {
// 1. 找到前驅(qū)節(jié)點(diǎn)
final Node p = node.predecessor();
// 2. 如果前驅(qū)節(jié)點(diǎn)是頭結(jié)點(diǎn)，就再次嘗試獲取鎖
if (p == head && tryAcquire(arg)) {
// 3. 獲取鎖成功后，把自己設(shè)置為頭節(jié)點(diǎn)
setHead(node);
p.next = null;
failed = false;
return interrupted;
}
// 4. 如果還是沒有獲取到鎖，找到可以將自己?jiǎn)拘训墓?jié)點(diǎn)
if (shouldParkAfterFailedAcquire(p, node) &&
// 5. 最后才放心地將自己掛起
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}再看一下shouldParkAfterFailedAcquire()方法，是怎么找到將自己?jiǎn)拘训墓?jié)點(diǎn)的？為什么要找這個(gè)節(jié)點(diǎn)？
// 加入同步隊(duì)列后，找到能將自己?jiǎn)拘训墓?jié)點(diǎn)
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
// 1. 如果前驅(qū)節(jié)點(diǎn)的狀態(tài)已經(jīng)是SIGNAL狀態(tài)（釋放鎖后，需要喚醒后繼節(jié)點(diǎn)），就無需操作了
if (ws == Node.SIGNAL)
return true;
// 2. 如果前驅(qū)節(jié)點(diǎn)的狀態(tài)是已取消，就繼續(xù)向前遍歷
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 3. 找到了不是取消狀態(tài)的節(jié)點(diǎn)，把該節(jié)點(diǎn)狀態(tài)設(shè)置成SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}從代碼中可以很清楚的看到，目的就是為了找到不是取消狀態(tài)的節(jié)點(diǎn)，并把該節(jié)點(diǎn)的狀態(tài)設(shè)置成SIGNAL。 狀態(tài)是SIGNAL的節(jié)點(diǎn)，釋放鎖后，需要喚醒其后繼節(jié)點(diǎn)。 簡(jiǎn)單理解就是：小弟初來乍到，特意來知會(huì)老大一聲，有好事，多通知小弟。 再看一下釋放鎖的邏輯。
2. 釋放鎖
釋放鎖的流程如下：
圖片
釋放鎖的代碼邏輯比較簡(jiǎn)單：
// 釋放鎖，傳參是1，表示釋放鎖一次
public final boolean release(int arg) {
// 1. 先嘗試釋放鎖，如果成功，則設(shè)置state-1，exclusiveOwnerThread=null（由子類實(shí)現(xiàn)）
if (tryRelease(arg)) {
Node h = head;
// 2. 如果同步隊(duì)列中還有其他節(jié)點(diǎn)，就喚醒下一個(gè)節(jié)點(diǎn)
if (h != null && h.waitStatus != 0)
// 3. 喚醒其后繼節(jié)點(diǎn)
unparkSuccessor(h);
return true;
}
return false;
}再看一下喚醒后繼節(jié)點(diǎn)的方法，作用就是重置頭節(jié)點(diǎn)狀態(tài)，然后找到一個(gè)有效的后繼節(jié)點(diǎn)并喚醒。
// 喚醒后繼節(jié)點(diǎn)
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
// 1. 如果頭節(jié)點(diǎn)不是取消狀態(tài)，就重置成初始狀態(tài)
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
// 2. 如果后繼節(jié)點(diǎn)是null或者是取消狀態(tài)
if (s == null || s.waitStatus > 0) {
s = null;
// 3. 從隊(duì)尾開始遍歷，找到一個(gè)有效狀態(tài)的節(jié)點(diǎn)
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
// 3. 喚醒這個(gè)有效節(jié)點(diǎn)
if (s != null)
LockSupport.unpark(s.thread);
}3. await等待
await等待的流程：
圖片
持有鎖的線程可以調(diào)用await()方法，在ConditionObject類里面。作用是：釋放鎖，并追加到條件隊(duì)列末尾。
// 等待方法
public final void await() throws InterruptedException {
// 如果線程已中斷，則拋出中斷異常
if (Thread.interrupted())
throw new InterruptedException();
// 1. 追加到條件隊(duì)列末尾
Node node = addConditionWaiter();
// 2. 釋放鎖
int savedState = fullyRelease(node);
int interruptMode = 0;
// 3. 有可能剛加入條件隊(duì)列就被轉(zhuǎn)移到同步隊(duì)列了，如果還在條件隊(duì)列，就可以放心地掛起自己
while (!isOnSyncQueue(node)) {
LockSupport.park(this);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
// 4. 如果已經(jīng)轉(zhuǎn)移到同步隊(duì)列，就嘗試獲取鎖
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
// 5. 清除條件隊(duì)列中已取消的節(jié)點(diǎn)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}再看一下addConditionWaiter方法，是怎么追加到條件隊(duì)列末尾的？
// 追加到條件隊(duì)列末尾
private Node addConditionWaiter() {
Node t = lastWaiter;
// 1. 清除已取消的節(jié)點(diǎn)，找到有效節(jié)點(diǎn)
if (t != null && t.waitStatus != Node.CONDITION) {
unlinkCancelledWaiters();
t = lastWaiter;
}
// 2. 創(chuàng)建Node節(jié)點(diǎn)，狀態(tài)是CONDITION（表示處于條件隊(duì)列）
Node node = new Node(Thread.currentThread(), Node.CONDITION);
// 3. 追加到條件隊(duì)列末尾
if (t == null)
firstWaiter = node;
else
t.nextWaiter = node;
lastWaiter = node;
return node;
}4. signal喚醒
signal喚醒的流程：
圖片
// 喚醒條件隊(duì)列的頭節(jié)點(diǎn)
public final void signal() {
// 1. 只有持有鎖的線程才能調(diào)用signal方法
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
// 2. 找到條件隊(duì)列的頭節(jié)點(diǎn)
Node first = firstWaiter;
if (first != null)
// 3. 開始喚醒
doSignal(first);
}
// 實(shí)際的喚醒方法
private void doSignal(Node first) {
do {
// 4. 從條件隊(duì)列中移除頭節(jié)點(diǎn)
if ((firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
first.nextWaiter = null;
// 5. 使用死循環(huán)，一定要轉(zhuǎn)移一個(gè)節(jié)點(diǎn)到同步隊(duì)列
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}到底是怎么轉(zhuǎn)移到同步隊(duì)列末尾的？
// 實(shí)際轉(zhuǎn)移方法
final boolean transferForSignal(Node node) {
// 1. 把節(jié)點(diǎn)狀態(tài)從CONDITION改成0，表示從條件隊(duì)列轉(zhuǎn)移到同步隊(duì)列
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
// 2. 使用死循環(huán)的方式，追加到同步隊(duì)列末尾（前面已經(jīng)講過）
Node p = enq(node);
int ws = p.waitStatus;
// 3. 把前驅(qū)節(jié)點(diǎn)狀態(tài)設(shè)置SIGNAL（通知他，別忘了喚醒老弟）
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
LockSupport.unpark(node.thread);
return true;
}上篇文章講了AQS的架構(gòu)設(shè)計(jì)和排它鎖的加鎖、釋放鎖流程，下篇文章接著講共享鎖的加鎖、釋放鎖流程。這篇文章開始講AQS的共享鎖加鎖和釋放鎖流程。
共享鎖
1. 加鎖
先看共享鎖的加鎖流程：
// 加鎖方法，傳參是1，表示加鎖一次
public final void acquireShared(int arg) {
// 1. 首先嘗試獲取鎖，返回值小于0，表示獲取鎖失敗
if (tryAcquireShared(arg) < 0) {
// 2. 獲取鎖失敗后，執(zhí)行的邏輯
doAcquireShared(arg);
}
}
// 獲取鎖失敗，執(zhí)行的邏輯
private void doAcquireShared(int arg) {
// 1. 把當(dāng)前線程包裝成Node節(jié)點(diǎn)追加到同步隊(duì)列末尾（前面已經(jīng)講過）
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (; ; ) {
// 2. 找到前驅(qū)節(jié)點(diǎn)
final Node p = node.predecessor();
// 3. 如果前驅(qū)節(jié)點(diǎn)是頭結(jié)點(diǎn)，就再次嘗試獲取鎖
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
// 3. 獲取鎖成功后，把自己設(shè)置為頭節(jié)點(diǎn)并向后傳播
setHeadAndPropagate(node, r);
p.next = null;
// 4. 檢查中斷狀態(tài)
if (interrupted) {
selfInterrupt();
}
failed = false;
return;
}
}
// 4. 如果獲取鎖失敗，把前驅(qū)節(jié)點(diǎn)狀態(tài)設(shè)置成SIGNAL，用來喚醒自己（前面講過）
if (shouldParkAfterFailedAcquire(p, node) &&
// 掛起并中斷當(dāng)前線程
parkAndCheckInterrupt()) {
interrupted = true;
}
}
} finally {
// 5. 如果獲取鎖失敗，就取消當(dāng)前節(jié)點(diǎn)
if (failed) {
cancelAcquire(node);
}
}
}看一下上面的第三步設(shè)置頭節(jié)點(diǎn)的邏輯，setHeadAndPropagate() 方法的作用就是：
- 設(shè)置新的頭節(jié)點(diǎn)
- 向后傳播共享鎖
這里就是共享鎖與排它鎖的區(qū)別，共享鎖的同步隊(duì)列中某個(gè)節(jié)點(diǎn)獲取到鎖時(shí)，會(huì)向后傳播，喚醒其他節(jié)點(diǎn)，也就是通知隊(duì)列中其他節(jié)點(diǎn)一起獲取鎖，。
// 設(shè)置頭節(jié)點(diǎn)，并向后傳播
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head;
setHead(node);
// propagate > 0 表示獲取到了共享鎖
// h == null || h.waitStatus < 0 表示當(dāng)前頭節(jié)點(diǎn)已經(jīng)不再是有效節(jié)點(diǎn)，可能是被取消或者已經(jīng)釋放了鎖，需要進(jìn)行傳播。
// 再次判斷頭節(jié)點(diǎn)，防止在設(shè)置頭節(jié)點(diǎn)的過程中發(fā)生競(jìng)爭(zhēng)
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
// 判斷如果后繼節(jié)點(diǎn)為空或者是共享節(jié)點(diǎn)，就開始傳播共享鎖
if (s == null || s.isShared()) {
doReleaseShared();
}
}
}再看一下上面第五步，獲取鎖失敗后，取消當(dāng)前節(jié)點(diǎn)的邏輯：
// 取消獲取鎖
private void cancelAcquire(Node node) {
// 判空
if (node == null) {
return;
}
// 1. 設(shè)置線程為null，不再持有鎖
node.thread = null;
// 2. 如果前驅(qū)節(jié)點(diǎn)是取消狀態(tài)，繼續(xù)向前遍歷，找到不是取消狀態(tài)的前驅(qū)節(jié)點(diǎn)
Node pred = node.prev;
while (pred.waitStatus > 0) {
node.prev = pred = pred.prev;
}
Node predNext = pred.next;
// 3. 把當(dāng)前節(jié)點(diǎn)設(shè)置為取消狀態(tài)，不再獲取鎖
node.waitStatus = Node.CANCELLED;
// 4. 判斷如果當(dāng)前節(jié)點(diǎn)是尾節(jié)點(diǎn)，就刪除當(dāng)前節(jié)點(diǎn)
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);
} else {
// 5. 判斷后繼節(jié)點(diǎn)是否需要被喚醒
int ws;
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
if (next != null && next.waitStatus <= 0) {
// 6. 刪除當(dāng)前節(jié)點(diǎn)
compareAndSetNext(pred, predNext, next);
}
} else {
// 7. 喚醒后繼節(jié)點(diǎn)
unparkSuccessor(node);
}
node.next = node;
}
}2. 釋放鎖
看一下釋放鎖的邏輯：
// 釋放鎖，傳參是1，表示釋放鎖一次
public final boolean releaseShared(int arg) {
// 先嘗試釋放鎖
if (tryReleaseShared(arg)) {
// 釋放鎖成功后，要執(zhí)行的邏輯
doReleaseShared();
return true;
}
return false;
}再看一下釋放鎖成功后，要執(zhí)行的 doReleaseShared() 方法的邏輯，作用是：
- 傳播共享鎖
- 喚醒同步隊(duì)列中線程
// 釋放鎖成功后，要執(zhí)行的邏輯
private void doReleaseShared() {
for (; ; ) {
Node h = head;
// 判斷是否等于尾節(jié)點(diǎn)，如果是尾節(jié)點(diǎn)，就不用傳播了
if (h != null && h != tail) {
// 判斷節(jié)點(diǎn)狀態(tài)，如果是SIGNAL，則需要被喚醒
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
// 重置head節(jié)點(diǎn)狀態(tài)，表示開始喚醒下個(gè)節(jié)點(diǎn)。如果重置失敗，說明發(fā)生了競(jìng)爭(zhēng)，需要再次嘗試。
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) {
continue;
}
// 喚醒下一個(gè)節(jié)點(diǎn)
unparkSuccessor(h);
// 如果節(jié)點(diǎn)狀態(tài)是0，則需要設(shè)置成PROPAGATE，繼續(xù)傳播
} else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) {
continue;
}
}
// 如果頭節(jié)點(diǎn)沒變，表示循環(huán)中沒有進(jìn)行頭節(jié)點(diǎn)的修改，說明已經(jīng)處理完了需要喚醒的節(jié)點(diǎn)，可以退出循環(huán)。
if (h == head) {
break;
}
}
}責(zé)任編輯：武曉燕
來源：
一燈架構(gòu)
