public class ReentrantLockTest {
public static void main(String[] args) throws InterruptedException {
// 聲明一個(gè)重入鎖
ReentrantLock lock = new ReentrantLock();
// 聲明一個(gè)條件鎖
Condition condition = lock.newCondition();
new Thread(()->{
try {
lock.lock(); // 1
try {
System.out.println("before await"); // 2
// 等待條件
condition.await(); // 3
System.out.println("after await"); // 10
} finally {
lock.unlock(); // 11
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
// 這里睡1000ms是為了讓上面的線程先獲取到鎖
Thread.sleep(1000);
lock.lock(); // 4
try {
// 這里睡2000ms代表這個(gè)線程執(zhí)行業(yè)務(wù)需要的時(shí)間
Thread.sleep(2000); // 5
System.out.println("before signal"); // 6
// 通知條件已成立
condition.signal(); // 7
System.out.println("after signal"); // 8
} finally {
lock.unlock(); // 9
}
}
}

public class ConditionObject implements Condition, java.io.Serializable {
/** First node of condition queue. */
private transient Node firstWaiter;
/** Last node of condition queue. */
private transient Node lastWaiter;
}

// ReentrantLock.newCondition()
public Condition newCondition() {
return sync.newCondition();
}
// ReentrantLock.Sync.newCondition()
final ConditionObject newCondition() {
return new ConditionObject();
}
// AbstractQueuedSynchronizer.ConditionObject.ConditionObject()
public ConditionObject() { }

// AbstractQueuedSynchronizer.ConditionObject.await()
public final void await() throws InterruptedException {
// 如果線程中斷了，拋出異常
if (Thread.interrupted())
throw new InterruptedException();
// 添加節(jié)點(diǎn)到Condition的隊(duì)列中，并返回該節(jié)點(diǎn)
Node node = addConditionWaiter();
// 完全釋放當(dāng)前線程獲取的鎖
// 因?yàn)殒i是可重入的，所以這里要把獲取的鎖全部釋放
int savedState = fullyRelease(node);
int interruptMode = 0;
// 是否在同步隊(duì)列中
while (!isOnSyncQueue(node)) {
// 阻塞當(dāng)前線程
LockSupport.park(this);

// 上面部分是調(diào)用await()時(shí)釋放自己占有的鎖，并阻塞自己等待條件的出現(xiàn)
// *************************分界線************************* //
// 下面部分是條件已經(jīng)出現(xiàn)，嘗試去獲取鎖

if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}

// 嘗試獲取鎖，注意第二個(gè)參數(shù)，這是上一章分析過的方法
// 如果沒獲取到會(huì)再次阻塞（這個(gè)方法這里就不貼出來了，有興趣的翻翻上一章的內(nèi)容）
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
// 清除取消的節(jié)點(diǎn)
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
// 線程中斷相關(guān)
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
// AbstractQueuedSynchronizer.ConditionObject.addConditionWaiter
private Node addConditionWaiter() {
Node t = lastWaiter;
// 如果條件隊(duì)列的尾節(jié)點(diǎn)已取消，從頭節(jié)點(diǎn)開始清除所有已取消的節(jié)點(diǎn)
if (t != null && t.waitStatus != Node.CONDITION) {
unlinkCancelledWaiters();
// 重新獲取尾節(jié)點(diǎn)
t = lastWaiter;
}
// 新建一個(gè)節(jié)點(diǎn)，它的等待狀態(tài)是CONDITION
Node node = new Node(Thread.currentThread(), Node.CONDITION);
// 如果尾節(jié)點(diǎn)為空，則把新節(jié)點(diǎn)賦值給頭節(jié)點(diǎn)（相當(dāng)于初始化隊(duì)列）
// 否則把新節(jié)點(diǎn)賦值給尾節(jié)點(diǎn)的nextWaiter指針
if (t == null)
firstWaiter = node;
else
t.nextWaiter = node;
// 尾節(jié)點(diǎn)指向新節(jié)點(diǎn)
lastWaiter = node;
// 返回新節(jié)點(diǎn)
return node;
}
// AbstractQueuedSynchronizer.fullyRelease
final int fullyRelease(Node node) {
boolean failed = true;
try {
// 獲取狀態(tài)變量的值，重復(fù)獲取鎖，這個(gè)值會(huì)一直累加
// 所以這個(gè)值也代表著獲取鎖的次數(shù)
int savedState = getState();
// 一次性釋放所有獲得的鎖
if (release(savedState)) {
failed = false;
// 返回獲取鎖的次數(shù)
return savedState;
} else {
throw new IllegalMonitorStateException();
}
} finally {
if (failed)
node.waitStatus = Node.CANCELLED;
}
}
// AbstractQueuedSynchronizer.isOnSyncQueue
final boolean isOnSyncQueue(Node node) {
// 如果等待狀態(tài)是CONDITION，或者前一個(gè)指針為空，返回false
// 說明還沒有移到AQS的隊(duì)列中
if (node.waitStatus == Node.CONDITION || node.prev == null)
return false;
// 如果next指針有值，說明已經(jīng)移到AQS的隊(duì)列中了
if (node.next != null) // If has successor, it must be on queue
return true;
// 從AQS的尾節(jié)點(diǎn)開始往前尋找看是否可以找到當(dāng)前節(jié)點(diǎn)，找到了也說明已經(jīng)在AQS的隊(duì)列中了
return findNodeFromTail(node);
}

// AbstractQueuedSynchronizer.ConditionObject.signal
public final void signal() {
// 如果不是當(dāng)前線程占有著鎖，調(diào)用這個(gè)方法拋出異常
// 說明signal()也要在獲取鎖之后執(zhí)行
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
// 條件隊(duì)列的頭節(jié)點(diǎn)
Node first = firstWaiter;
// 如果有等待條件的節(jié)點(diǎn)，則通知它條件已成立
if (first != null)
doSignal(first);
}
// AbstractQueuedSynchronizer.ConditionObject.doSignal
private void doSignal(Node first) {
do {
// 移到條件隊(duì)列的頭節(jié)點(diǎn)往后一位
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
// 相當(dāng)于把頭節(jié)點(diǎn)從隊(duì)列中出隊(duì)
first.nextWaiter = null;
// 轉(zhuǎn)移節(jié)點(diǎn)到AQS隊(duì)列中
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
// AbstractQueuedSynchronizer.transferForSignal
final boolean transferForSignal(Node node) {
// 把節(jié)點(diǎn)的狀態(tài)更改為0，也就是說即將移到AQS隊(duì)列中
// 如果失敗了，說明節(jié)點(diǎn)已經(jīng)被改成取消狀態(tài)了
// 返回false，通過上面的循環(huán)可知會(huì)尋找下一個(gè)可用節(jié)點(diǎn)
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
// 調(diào)用AQS的入隊(duì)方法把節(jié)點(diǎn)移到AQS的隊(duì)列中
// 注意，這里enq()的返回值是node的上一個(gè)節(jié)點(diǎn)，也就是舊尾節(jié)點(diǎn)
Node p = enq(node);
// 上一個(gè)節(jié)點(diǎn)的等待狀態(tài)
int ws = p.waitStatus;
// 如果上一個(gè)節(jié)點(diǎn)已取消了，或者更新狀態(tài)為SIGNAL失?。ㄒ彩钦f明上一個(gè)節(jié)點(diǎn)已經(jīng)取消了）
// 則直接喚醒當(dāng)前節(jié)點(diǎn)對(duì)應(yīng)的線程
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
LockSupport.unpark(node.thread);
// 如果更新上一個(gè)節(jié)點(diǎn)的等待狀態(tài)為SIGNAL成功了
// 則返回true，這時(shí)上面的循環(huán)不成立了，退出循環(huán)，也就是只通知了一個(gè)節(jié)點(diǎn)
// 此時(shí)當(dāng)前節(jié)點(diǎn)還是阻塞狀態(tài)
// 也就是說調(diào)用signal()的時(shí)候并不會(huì)真正喚醒一個(gè)節(jié)點(diǎn)
// 只是把節(jié)點(diǎn)從條件隊(duì)列移到AQS隊(duì)列中
return true;
}