Lock(五) — LockSupport 和 Condition接口

一、概述

任意一個Java對象，都擁有一組監視器方法（定義在java.lang.Object上）。
主要包括 wait()、wait(long timeout)、notify()、notifyAll() 方法，這些方法與synchronized同步關鍵字配合，可以實現 等待/通知模式。

Object的等待/通知模式如下：

Condition 接口也提供了類似 Object 的監視器方法，與 Lock 配合可以實現等待/通知模式，但這兩者在使用方式以及功能特性上有差別。

Object監視器方法與Condition接口對比如下圖：

---

二、Condition 接口與示例

1. 使用示例

Condition 定義了等待/通知兩種類型的方法，Condition對象由Lock.newCondition() 方法創建出來。

注意：
當前線程調用等待/通知兩種類型方法時，需要提前獲取到Condition對象關聯的鎖。

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

public void conditionWait() throws InterruptedException {
    lock.lock(); //1.先獲取鎖
    try {
        condition.await(); //2.讓當前線程進入等待隊列，同時會釋放持有的鎖。
    } finally {
        lock.unlock(); //3.釋放鎖
    }
}

public void conditionSignal() throws InterruptedException {
    lock.lock(); //1.先獲取鎖
    try {
        condition.signal(); //2.喚醒等待隊列中頭節點線程，使之進入AQS同步隊列。
    } finally {
        lock.unlock(); //3.釋放鎖
    }
}

2. Condition 接口

Condition 接口內的方法主要分爲兩部分：

1. 以 await 開頭的方法使當前線程進入等待隊列；
2. 以 signal 開頭的方法使當前線程從等待隊列進入到AQS的同步隊列中；

該接口的應用可以參考：ArrayBlockingQueue源碼分析

---

三、Condition 實現原理

ConditionObject 是同步器 AbstractQueuedSynchronizer 的內部類。每個Condition對象都包含着一個隊列（稱爲等待隊列），該隊列是Condition對象實現等待/通知功能的關鍵。

說明：
AbstractQueuedSynchronizer 內維護的隊列稱爲： 同步隊列
Condition 內維護的隊列稱爲： 等待隊列

下面分析Condition的實現，分爲三部分：

1. 等待隊列
2. 等待
3. 通知

1. 等待隊列

1. 等待隊列是一個FIFO的隊列。
2. 隊列中的每個節點都包含了一個線程引用，該線程就是在Condition對象上等待的線程。
3. 如果一個線程調用了Condition.await()方法，那麼該線程將會釋放鎖、構造成節點加入等待隊列並進入等待狀態 (節點的定義複用了同步器中節點的定義)。
4. 一個 Condition 包含一個等待隊列，Condition擁有首節點（firstWaiter）和尾節點（lastWaiter）。

當前線程調用 Condition.await() 方法後，將會以當前線程構造節點，並將節點從尾部加入等待隊列。加入尾部的過程並沒有使用CAS保證，原因在於調用await()方法的線程必定是獲取了鎖的線程，也就是說該過程是由鎖來保證線程安全的。

等待隊列的基本結構如圖所示：

Object 和 Lock 中同步隊列、等待隊列個數的差異：

1. 在 Object 的監視器模型上，一個對象擁有 一個同步隊列 和 一個等待隊列。
2. Lock（更確切地說是同步器）擁有 一個同步隊列 和 多個等待隊列，其對應關係如圖所示。
   

2. 等待

調用以 await 開頭的方法（如Condition.await()方法），會使當前線程進入等待隊列並釋放鎖，同時線程狀態變爲等待狀態。當從await()方法返回時，當前線程一定獲取了Condition相關聯的鎖。

如果從隊列（同步隊列和等待隊列）的角度看await()方法，當調用await()方法時，相當於同步隊列的首節點（獲取了鎖的節點）移動到Condition的等待隊列中。

// AbstractQueuedSynchronizer.ConditionObject.class
public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    // 當前線程加入等待隊列
    Node node = addConditionWaiter();
    // 釋放同步狀態，也就是釋放鎖
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        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);
}

調用該方法的線程成功獲取了鎖的線程，也就是同步隊列中的首節點，該方法會將當前線程構造成節點並加入等待隊列中，然後釋放同步狀態，喚醒同步隊列中的後繼節點，然後當前線程會進入等待狀態。

當等待隊列中的節點被喚醒，則喚醒節點的線程開始嘗試獲取同步狀態。如果不是通過其他線程調用Condition.signal()方法喚醒，而是對等待線程進行中斷，則會拋出InterruptedException。

如果從隊列的角度去看，當前線程加入Condition 等待隊列的過程 如圖示。

3. 通知

調用Condition的signal()方法，將會喚醒在等待隊列中等待時間最長的節點（首節點），在喚醒節點之前，會將節點移到同步隊列中。
Condition的signal()方法，如代碼如下所示：

public final void signal() {
    if (!isHeldExclusively()) //1.校驗是否獲取鎖(在調用signal()方法的前提是當前線程必須持有鎖)
        throw new IllegalMonitorStateException();
    Node first = firstWaiter; //2.獲取等待隊列的首節點
    if (first != null)
        doSignal(first); //3.將等待隊列中的首節點移動到同步隊列中，並喚醒該節點中的線程。
}

調用 signal() 方法有如下3步驟：

1. 前置條件： 調用該方法前，當前線程必須獲取了鎖。因此進行了isHeldExclusively()檢查。
2. 接着獲取等待隊列的首節點。
3. 將其移動到同步隊列並使用LockSupport喚醒節點中的線程。

節點從等待隊列移動到同步隊列的過程如圖所示。

通過調用同步器的enq(Node node)方法，等待隊列中的頭節點線程安全地移動到同步隊列。當節點移動到同步隊列後，當前線程再使用LockSupport喚醒該節點的線程。

被喚醒後的線程，將從await()方法中的while循環中退出（isOnSyncQueue(Node node) 方法返回true，節點已經在同步隊列中），進而調用同步器的 acquireQueued() 方法加入到獲取同步狀態的競爭中。

成功獲取同步狀態（或者說鎖）之後，被喚醒的線程將從先前調用的await()方法返回，此時該線程已經成功地獲取了鎖。

Condition的 signalAll() 方法，相當於對等待隊列中的每個節點均執行一次signal()方法，效果就是將等待隊列中所有節點全部移動到同步隊列中，並喚醒每個節點的線程。

4. Condition 的應用

該接口的應用可以參考：ArrayBlockingQueue源碼分析

---

四、LockSupport 類

LockSupport 定義了一組的公共靜態方法，這些方法提供了最基本的線程阻塞和喚醒功能，而LockSupport也成爲構建同步組件的基礎工具。

1. 以 park 開頭的方法用來阻塞當前線程。
2. 以 unpark(Thread thread) 方法來喚醒一個被阻塞的線程。

---

五、參考

1. 《Java併發編程的藝術》