# Java 併發程式設計解析 | 基於 JDK 原始碼解析 Java 領域中 ReentrantLock 鎖的設計思想與實現原理

最近我從cnaaa.com購買了雲伺服器。

> 在 Java 領域中，我們可以將鎖大致分為基於 Java 語法層面 (關鍵詞) 實現的鎖和基於 JDK 層面實現的鎖。

![img](https://pic.imgdb.cn/item/632c052c16f2c2beb1148571.png)

在 Java 領域中，尤其是在併發程式設計領域，對於多執行緒併發執行一直有兩大核心問題：同步和互斥。其中：

- 互斥 (Mutual Exclusion)：一個公共資源同一時刻只能被一個程式或執行緒使用，多個程式或執行緒不能同時使用公共資源。即就是同一時刻只允許一個執行緒訪問共享資源的問題。
- 同步 (Synchronization)：兩個或兩個以上的程式或執行緒在執行過程中協同步調，按預定的先後次序執行。即就是執行緒之間如何通訊、協作的問題。

針對對於這兩大核心問題，利用管程是能夠解決和實現的，因此可以說，管程是併發程式設計的萬能法寶。 雖然，Java 在基於語法層面 (synchronized 關鍵字) 實現了對管程技術，但是從使用方式和效能上來說，內建鎖 (synchronized 關鍵字) 的粒度相對過大，不支援超時和中斷等問題。 為了彌補這些問題，從 JDK 層面對其 “重複造輪子”，在 JDK 內部對其重新設計和定義，甚至實現了新的特性。 在 Java 領域中，從 JDK 原始碼分析來看，基於 JDK 層面實現的鎖大致主要可以分為以下 4 種方式：

![img](https://pic.imgdb.cn/item/632c052c16f2c2beb1148578.png)

- 基於 Lock 介面實現的鎖：JDK1.5 版本提供的 ReentrantLock 類
- 基於 ReadWriteLock 介面實現的鎖：JDK1.5 版本提供的 ReentrantReadWriteLock 類
- 基於 AQS 基礎同步器實現的鎖：JDK1.5 版本提供的併發相關的同步器 Semaphore，CyclicBarrier 以及 CountDownLatch 等�
- 基於自定義 API 操作實現的鎖：JDK1.8 版本中提供的 StampedLock 類

從閱讀原始碼不難發現，在 Java SDK 併發包主要透過 AbstractQueuedSynchronizer (AQS) 實現多執行緒同步機制的封裝與定義，而透過 Lock 和 Condition 兩個介面來實現管程，其中 Lock 用於解決互斥問題，Condition 用於解決同步問題。

------

## 一.AQS 基礎同步器基本理論

> 在 Java 領域中，同步器是專門為多執行緒併發設計的同步機制，主要是多執行緒併發執行時執行緒之間透過某種共享狀態來實現同步，只有當狀態滿足這種條件時執行緒才往下執行的一種同步機制。

![img](https://pic.imgdb.cn/item/632c052c16f2c2beb1148583.png) 一個標準的 AQS 同步器主要有同步狀態機制，等待佇列，條件佇列，獨佔模式，共享模式等五大核心要素組成。 在 Java 領域中，JDK 的 JUC (java.util.concurrent.) 包中提供了各種併發工具，但是大部分同步工具的實現基於 AbstractQueuedSynchronizer 類實現，其內部結構主要如下：

- 同步狀態機制 (Synchronization Status)：主要用於實現鎖 (Lock) 機制，是指同步狀態，其要求對於狀態的更新必須原子性的
- 等待佇列 (Wait Queue)：主要用於存放等待執行緒獲取到的鎖資源，並且把執行緒維護到一個 Node (節點) 裡面和維護一個非阻塞的 CHL Node FIFO (先進先出) 佇列，主要是採用自旋鎖 + CAS 操作來保證節點插入和移除的原子性操作。
- 條件佇列 (Condition Queue)：用於實現鎖的條件機制，一般主要是指替換 “等待 - 通知” 工作機制，主要是透過 ConditionObject 物件實現 Condition 介面提供的方法實現。
- 獨佔模式 (Exclusive Mode)：主要用於實現獨佔鎖，主要是基於靜態內部類 Node 的常量標誌 EXCLUSIVE 來標識該節點是獨佔模式
- 共享模式 (Shared Mode)：主要用於實現共享鎖，主要是基於靜態內部類 Node 的常量標誌 SHARED 來標識該節點是共享模式

我們可以得到一個比較通用的併發同步工具基礎模型，大致包含如下幾個內容，其中： ![img](https://pic.imgdb.cn/item/632c052c16f2c2beb114858c.png)

- 條件變數 (Conditional Variable)： 利用執行緒間共享的變數進行同步的一種工作機制
- 共享變數 ((Shared Variable))：一般指物件實體物件的成員變數和屬性
- 阻塞佇列 (Blocking Queue)：共享變數 (Shared Variable) 及其對共享變數的操作統一封裝
- 等待佇列 (Wait Queue)：每個條件變數都對應有一個等待佇列 (Wait Queue), 內部需要實現入隊操作 (Enqueue) 和出隊操作 (Dequeue) 方法
- 變數狀態描述機 (Synchronization Status)：描述條件變數和共享變數之間狀態變化，又可以稱其為同步狀態
- 工作模式 (Operation Mode)： 執行緒資源具有排他性，因此定義獨佔模式和共享模式兩種工作模式

綜上所述，條件變數和等待佇列的作用是解決執行緒之間的同步問題；共享變數與阻塞佇列的作用是解決執行緒之間的互斥問題。

## 二. JDK 顯式鎖統一概念模型

> 在併發程式設計領域，有兩大核心問題：一個是互斥，即同一時刻只允許一個執行緒訪問共享資源；另一個是同步，即執行緒之間如何通訊、協作。

![img](https://pic.imgdb.cn/item/632c052c16f2c2beb1148596.png)

綜合 Java 領域中的併發鎖的各種實現與應用分析來看，一把鎖或者一種鎖，基本上都會包含以下幾個方面：

- 鎖的同步器工作機制：主要是考慮共享模式還是獨享模式，是否支援超時機制，以及是否支援超時機制？
- 鎖的同步器工作模式：主要是基於 AQS 基礎同步器封裝內部同步器，是否考慮公平 / 非公平模式？
- 鎖的狀態變數機制： 主要鎖的狀態設定，是否共享狀態變數？
- 鎖的佇列封裝定義：主要是指等待佇列和條件佇列，是否需要條件佇列或者等待佇列定義？
- 鎖的底層實現操作： 主要是指底層 CL 鎖和 CAS 操作，是否需要考慮自旋鎖或者 CAS 操作例項物件方法？
- 鎖的組合實現新鎖： 主要是基於獨佔鎖和共享鎖，是否考慮對應 API 自定義操作實現？

綜上所述，大致可以根據上述這些方向，我們便可以清楚?️知道 Java 領域中各種鎖實現的基本理論時和實現思想。

## 三.ReentrantLock (可重入鎖) 的設計與實現

> 在 Java 領域中，ReentrantLock (可重入鎖) 是針對於 Java 多執行緒併發控制中對一個執行緒可以多次對某個鎖進行加鎖操作，主要是基於內建的 AQS 基礎抽象佇列同步器實現的一種併發控制工具類。

![img](https://pic.imgdb.cn/item/632c052d16f2c2beb1148635.png) 一般來說，對於同一個執行緒是否可以重複佔有同一個鎖物件的角度來分，大致主要可以分為可重入鎖與不可重入鎖。其中：

- 可重入鎖：一個執行緒可以多次搶佔同一個鎖，也就意味著能夠支援一個執行緒對資源的重複加鎖，或者說，一個執行緒可以多次進入同一個鎖所同步的臨界區程式碼塊。
- 不可重入鎖：一個執行緒只能搶佔一次同一個鎖，也就意味著在同一時刻只能有一個執行緒獲取到鎖，而其他獲取鎖的執行緒只能等待，只有擁有鎖的執行緒釋放了鎖後，其他的執行緒才能夠獲取鎖。

ReentrantLock 是 JDK 中顯式鎖一個主要基於 Lock 介面 API 實現的基礎實現類，擁有與內建鎖 (synchronized) 相同的併發性和記憶體語義，同時提供了限時搶佔、可中斷搶佔等一些高階鎖特性。 除此之外，ReentrantLock 基於內建的 AQS 基礎抽象佇列同步器實現，線上程參與鎖資源競爭比較激烈的場景下，能表現出比內建鎖較佳的效能。 而且，ReentrantLock 是一種獨佔鎖，在獨佔模式下只能逐一使用鎖，也就是說，任意時刻最多隻會有一個執行緒持有鎖的控制權。

### 1. 設計思想

![img](https://pic.imgdb.cn/item/632c052d16f2c2beb1148638.png)

ReentrantLock 類最早是在 JDK1.5 版本提供的，從設計思想上來看，主要包括同步器工作模式，獲取鎖方法，釋放鎖方法以及定義 Condition 佇列方法等 4 個核心要素。其中：

- 實現 Lock 介面 ：主要基於 Lock 介面 API 實現對應方法，擁有與內建鎖 (synchronized) 相同的併發性和記憶體語義，用於支援和解決解決互斥問題。
- 同步器工作模式：基於 AQS 基礎抽象佇列同步器封裝內建實現一個靜態的內建同步器抽象類，然後基於這個抽象類分別實現了公平同步器和非公平同步器，用來指定和描述同步器工作模式是公平模式還是非公平模式。
- 公平 / 非公平模式：主要描述的是多個執行緒在同時獲取鎖時是否按照先到先得的順序獲取鎖，如果是則為公平模式，否則為非公平模式。
- 獲取鎖方法：主要定義了一個 lock () 方法來獲取鎖，表示假如鎖已經被其他執行緒佔有或持有，其當前獲取鎖的執行緒則進入等待狀態。
- 釋放鎖方法：主要定義了一個 unlock () 方法來釋放鎖，表示假如鎖已經被其他執行緒放棄或釋放，其當前獲取鎖的執行緒則獲得該鎖。
- 定義 Condition 佇列操作方法： 主要是基於 Condition 介面來定義一個方法實現鎖的條件機制，用於支援執行緒的阻塞和喚醒功能即就是解決同步問題，也就是我們說的執行緒間的通訊方式。
- 定義等待佇列操作方法： 主要是依據條件佇列來時進行對應的操作，間接適配 AQS 基礎同步器中對於等待佇列的功能，保證獲取鎖的順序的公平性

------

### 2. 基本實現

![img](https://pic.imgdb.cn/item/632c052d16f2c2beb1148648.png)

在 ReentrantLock 類的 JDK1.8 版本中，對於 ReentrantLock 的基本實現如下：

```java
public class ReentrantLock implements Lock, java.io.Serializable {

private static final long serialVersionUID = 7373984872572414699 L;

/**
     * ReentrantLock鎖-定義支援同步器實現
     */
    private final Sync sync;

/**
     * ReentrantLock鎖-基於AQS定義支援同步器實現
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860 L;

/**
         * ReentrantLock鎖-定義支援同步器Sync獲取鎖方法
         */
        abstract void lock();
				
        //......其他方法程式碼
    }

/**
     * ReentrantLock鎖-構造同步器預設工作模式(預設非公平模式)
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

/**
     * ReentrantLock鎖-構造同步器指定工作模式(可選公平/非公平模式)
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

/**
     * ReentrantLock鎖-獲取鎖(普通模式)
     */
    public void lock() {
        sync.lock();
    }

/**
     * ReentrantLock鎖-釋放鎖
     */
    public void unlock() {
        sync.release(1);
    }

/**
     * ReentrantLock鎖-建立鎖的條件機制
     */
    public Condition newCondition() {
        return sync.newCondition();
    }

//......其他方法程式碼
}
```

- 內部同步器：基於 AQS 基礎同步器封裝和定義了一個靜態內部 Sync 抽象類，其中抽象了一個內建鎖 lock () 方法
- 同步器工作模式：提供了 2 個構造方法，其中無引數構造方法表示的是預設的工作模式，有引數構造方法主要依據引數來實現指定的工作模式
- 獲取鎖： 主要是提供了 lock () 方法，呼叫的靜態內部 Sync 抽象類內建鎖 lock () 方法，而本質上是 AQS 同步器中的 acquire () 方法
- 釋放鎖： 主要是提供了 unlock () 方法，而本質上是呼叫的 AQS 同步器中的 release () 方法
- 建立條件佇列： 主要是基於 Condition 介面定義了 newCondition () 方法，呼叫的靜態內部 Sync 抽象類 ewCondition () 方法，而本質上是呼叫的 AQS 同步器中的 ConditionObject 中的 newCondition () 方法

#### 2.1 基於 AQS 同步器封裝靜態內部 Sync 抽象類

```java
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

/**
         * ReentrantLock鎖-內部同步器Sync的內建加鎖方法
         */
        abstract void lock();

/**
 * ReentrantLock鎖-內部同步器Sync的非公平獲取鎖
 */
 final boolean nonfairTryAcquire(int acquires) {
 final Thread current = Thread.currentThread();
 int c = getState();
 if (c == 0) {
 if (compareAndSetState(0, acquires)) {
 setExclusiveOwnerThread(current);
 return true;
 }
 }
 else if (current == getExclusiveOwnerThread()) {
 int nextc = c + acquires;
 if (nextc < 0) // overflow
 throw new Error("Maximum lock count exceeded");
 setState(nextc);
 return true;
 }
 return false;
 }

/**
         * ReentrantLock鎖-內部同步器Sync的嘗試釋放
         */
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

/**
         * ReentrantLock鎖-內部同步器Sync的檢查執行緒是否獨佔
         */
        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

/**
         * ReentrantLock鎖-內部同步器Sync的條件機制
         */
        final ConditionObject newCondition() {
            return new ConditionObject();
        }

/**
         * ReentrantLock鎖-內部同步器Sync的判斷鎖持有者
         */
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

/**
         * ReentrantLock鎖-內部同步器Sync的獨佔狀態
         */
        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

/**
         * ReentrantLock鎖-內部同步器Sync的是否被鎖
         */
        final boolean isLocked() {
            return getState() != 0;
        }

/**
         * ReentrantLock鎖-內部同步器Sync的流化處理物件
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
				
    }
```

- Sync 類：FairSync 公平同步器和 NonfairSync 非公平同步器的抽象父類。
- 校驗 isHeldExclusively () 方法： ReentrantLock 鎖是屬於獨佔模式，需要當前鎖持有執行緒與當前執行緒是否一致
- nonfairTryAcquire () 方法： 一般主要用於非公平模式獲取鎖，其核心是 compareAndSetState 方法和 setExclusiveOwnerThread 方法
- tryRelease () 方法： 其公平 / 非公平模式都是透過 ryRelease () 來釋放鎖操作
- newCondition () 方法： 基於 AQS 同步器的 ConditionObject 物件封裝實現，提供給 ReentrantLock 類使用
- 私有 readObject () 方法：對於輸入的物件進行流化處理

特別需要注意的是，我們需要重點關注 nonfairTryAcquire () 方法和 tryRelease () 方法，其中：

- 獲取非公平鎖 nonfairTryAcquire () 方法：主要是用於獲取 AQS 的狀態變數 status，其預設取值範圍是 0 和 1，其中，0 表示未被加鎖，1 表示已經被加鎖
  - 如果狀態變數 status=0，使用 compareAndSetState 方法進行 CAS 原子修改操作，把狀態變數修改為 1，並且透過 setExclusiveOwnerThread 設定當前執行緒為鎖的持有執行緒
  - 如果狀態變數 status=1，表示當前執行緒為鎖的持有執行緒，正在進入鎖重入操作，狀態變數累加 1，超過重入次數時，會丟擲 throw new Error ("Maximum lock count exceeded")
- 釋放鎖 tryRelease () 方法：主要是檢查當前執行緒是否為鎖持有執行緒，隨後 AQS 同步器狀態變數減 1，如果不是 throw new IllegalMonitorStateException ()
  - 如果狀態變數 status=0，表示鎖已經釋放成功，透過 setExclusiveOwnerThread 設定鎖的持有執行緒為 null，也就是置空鎖的持有執行緒
  - 如果狀態變數 status !=0,  需要狀態變數遞減 1 即可，直到鎖已經釋放成功

#### 2.2 基於 Sync 抽象類封裝 FairSync 公平同步器

```java
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

/**
         * ReentrantLock鎖-公平模式-獲取鎖
         */
        final void lock() {
            acquire(1);
        }

/**
 * ReentrantLock鎖-公平模式-嘗試獲取鎖
 */
 protected final boolean tryAcquire(int acquires) {
 final Thread current = Thread.currentThread();
 int c = getState();
 if (c == 0) {
 if (!hasQueuedPredecessors() &&
 compareAndSetState(0, acquires)) {
 setExclusiveOwnerThread(current);
 return true;
 }
 }
 else if (current == getExclusiveOwnerThread()) {
 int nextc = c + acquires;
 if (nextc < 0)
 throw new Error("Maximum lock count exceeded");
 setState(nextc);
 return true;
 }
 return false;
 }
 }
```

- 實現方式： 主要基於 AQS 封裝的內部靜態抽象 Sync 同步類實現，使用的 AQS 的獨佔模式。
- 主要方法： 主要提供了 lock () 和 tryAcquire () 方法，其嚴格意義上來說，僅僅只是實現了 tryAcquire () 方法，但是最關鍵的使用 hasQueuedPredecessors 來保證了鎖的公平性。
- 鎖獲取方式： 主要是採用完全透過佇列來實現實現公平機制，即就是檢查是否存在等待佇列，如果佇列之中已經存在其他執行緒，直接放棄操作。

#### 2.3 基於 Sync 抽象類封裝 NonfairSync 非公平同步器

```java
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

/**
         * ReentrantLock鎖-非公平模式-獲取鎖
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

/**
         * ReentrantLock鎖-非公平模式-嘗試獲取鎖
         */
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
```

- 實現方式： 主要基於 AQS 封裝的內部靜態抽象 Sync 同步類實現，使用的 AQS 的獨佔模式。
- 主要方法： 主要提供了 lock () 和 tryAcquire () 方法，其嚴格意義上來說，僅僅只是實現了 tryAcquire () 方法，直接呼叫了 Sync 同步類的 nonfairTryAcquire () 方法。
- 鎖獲取方式： 主要是採用闖入策略來打破鎖的公平，也就是一般準備獲取鎖的執行緒會先嚐試獲取鎖，失敗之後才進入佇列中。

### 3. 具體實現

![img](https://pic.imgdb.cn/item/632c052d16f2c2beb1148654.png)

在 ReentrantLock 類的 JDK1.8 版本中，對於 ReentrantLock 的具體實現如下：

```java
public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699 L;
    /** Synchronizer providing all implementation mechanics */
    private final Sync sync;

/**
     * ReentrantLock鎖-基於AQS定義支援同步器實現
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860 L;

/**
         * ReentrantLock鎖-定義支援同步器Sync獲取鎖方法
         */
        abstract void lock();
				
        //......其他方法程式碼
    }

/**
     * ReentrantLock鎖-構造同步器預設工作模式(預設非公平模式)
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

/**
     * ReentrantLock鎖-構造同步器指定工作模式(可選公平/非公平模式)
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

/**
     * ReentrantLock鎖-獲取鎖(普通模式)
     */
    public void lock() {
        sync.lock();
    }

/**
     * ReentrantLock鎖-釋放鎖
     */
    public void unlock() {
        sync.release(1);
    }

/**
     * ReentrantLock鎖-建立鎖的條件機制
     */
    public Condition newCondition() {
        return sync.newCondition();
    }
		
    /**
     * ReentrantLock鎖-獲取鎖(支援可中斷機制)
     */
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

/**
     * ReentrantLock鎖-嘗試獲取鎖(普通模式)
     */
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

/**
     * ReentrantLock鎖-嘗試獲取鎖(支援超時)
     */
    public boolean tryLock(long timeout, TimeUnit unit)
    throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

/**
     * ReentrantLock鎖-統計當前執行緒所持有數量
     */
    public int getHoldCount() {
        return sync.getHoldCount();
    }

/**
     * ReentrantLock鎖-檢測當前執行緒是否獨佔
     */
    public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }

/**
     * ReentrantLock鎖-檢測是否被加鎖
     */
    public boolean isLocked() {
        return sync.isLocked();
    }

/**
     * ReentrantLock鎖-檢測是否公平模式
     */
    public final boolean isFair() {
        return sync instanceof FairSync;
    }

/**
     * ReentrantLock鎖-獲取當前鎖持有執行緒
     */
    protected Thread getOwner() {
        return sync.getOwner();
    }

/**
     * ReentrantLock鎖-檢測輪詢執行緒是否存在佇列中
     */
    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

/**
     * ReentrantLock鎖-檢測執行緒是否存在佇列中
     */
    public final boolean hasQueuedThread(Thread thread) {
        return sync.isQueued(thread);
    }

/**
     * ReentrantLock鎖-獲取佇列數量
     */
    public final int getQueueLength() {
        return sync.getQueueLength();
    }

/**
 * ReentrantLock鎖-獲取佇列中的所有執行緒
 */
 protected Collection < Thread > getQueuedThreads() {
 return sync.getQueuedThreads();
 }

/**
     * ReentrantLock鎖-檢測存在條件佇列是否入隊狀態
     */
    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject) condition);
    }

/**
     * ReentrantLock鎖-獲取等待佇列的長度
     */
    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject) condition);
    }

/**
 * ReentrantLock鎖-獲取等待佇列的執行緒物件
 */
 protected Collection < Thread > getWaitingThreads(Condition condition) {
 if (condition == null)
 throw new NullPointerException();
 if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
 throw new IllegalArgumentException("not owner");
 return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject) condition);
 }

}
```

- 獲取鎖的方法：主要提供了一般模式 lock () 方法，支援可中斷機制 lockInterruptibly () 方法，無引數 tryLock () 方法以及有引數的支援超時機制的 tryLock (long timeout, TimeUnit unit) 方法
- 釋放鎖的方法：主要是 unlock () 方法，間接呼叫是內部同步器中的 release () 方法
- 條件佇列操作：主要提供了獲取佇列中的執行緒物件 getQueuedThreads ()，檢測佇列入隊 hasWaiters (Condition condition) 方法，以及
- 等待佇列操作：主要提供了獲取佇列中的執行緒物件 getWaitingThreads (Condition condition)，檢測佇列入隊 hasQueuedThread (Thread thread) 方法，以及獲取佇列長度 getQueueLength () 方法和 getWaitingThreads (Condition condition) 方法
- 其他檢測判斷：主要有判斷是否公平模式 isFair () 方法，是否當前執行緒獨佔 isHeldByCurrentThread () 方法，以及是否加鎖 isLocked () 等

需要注意的是，在 JDK1.8 版本之後，對於 ReentrantLock 的實現有些細微的變化，感興趣的可自行參考相關版本的原始碼進行對比分析。

綜上所述，從一定意義上講，ReentrantLock 是一種可重入的獨佔 (互斥) 鎖，屬於 AQS 基礎抽象佇列同步器中獨佔模式孵化的產物，支援公平模式與非公平模式，預設採用非公平模式。

Java 併發程式設計解析

相關文章