> `ReentrantLock`不但是可重入鎖，而且還是公平或非公平鎖，在工作中會經常使用到，將自己對這兩種鎖的理解記錄下來，希望對大家有幫助。 ## 前提條件 在理解`ReentrantLock`時需要具備一些基本的知識 ### 理解AQS的實現原理 之前有寫過一篇[《深入淺出AQS原始碼解析》](https://www.cnblogs.com/pinxiong/p/13288201.html)關於AQS的文章，對AQS原理不瞭解的同學可以先看一下 ### 什麼是可重入鎖 當一個執行緒已經持有鎖，如果該現在再次獲取鎖，是否可以獲取成功？如果能獲取成功則說明該鎖是**可重入的**，否則是**不可重入的** ### 什麼是公平鎖和非公平鎖 公平與非公平的一個很本質的區別就是，是否遵守FIFO（也就是先來後到）。當有多個執行緒來申請鎖的時候，是否先申請的執行緒先獲取鎖，後申請的執行緒後獲取鎖？如果是的，則是**公平鎖**，否則是**非公平鎖**。 **更準確地說，先申請鎖的執行緒先獲得鎖競爭的權利**。對於公平的排他鎖而言，先申請鎖的執行緒會先獲取鎖，但是對於公平的共享鎖而言，先申請鎖的執行緒會先擁有獲取鎖競爭的權利，其他等待共享鎖的執行緒也會被喚醒，有可能後喚醒的執行緒先獲取鎖。 ## ReentrantLock 原始碼解析 `ReentrantLock`的功能主要是通過3個內部類`Sync`、`FairSync`和`NonfairSync`來實現的，這3個內部類繼承了`AbstractQueuedSynchronizer`，其中`FairSync`和`NonfairSync`類繼承了`Sync`，接下來我們一一解讀這幾個內部類。 ### ReentrantLock.Sync類原始碼解析 由於ReentrantLock.Sync類中的核心程式碼比較少，原理也比較簡單，所以就直接在程式碼中通過詳細註釋的方式來解讀 ``` abstract static class Sync extends AbstractQueuedSynchronizer { /** * 定義了一個抽象方法，用來獲取鎖 */ abstract void lock(); /** * NonfairSync中tryAcquire和、ReentrantLock.tryLock會使用到 * 重要功能：快速嘗試獲取鎖，如果能夠獲取鎖返回true，否則返回false * 在嘗試獲取鎖的過程中，不會阻塞當前執行緒，一般情況下是當前執行緒已經持有鎖時 * 才有可能是可以直接獲取鎖，這也是可重入功能的核心實現 */ final boolean nonfairTryAcquire(int acquires) { // 獲取當前執行緒 final Thread current = Thread.currentThread(); /** * state是AQS對外提供的一個變數，讓不同的實現類可以通過這個變數 * 來控制鎖被執行緒獲取鎖的次數 */ int c = getState(); // 當state為0表示該鎖是沒有被任何執行緒持有 if (c == 0) { /** * CAS操作如果成功，說明當前執行緒競爭到了鎖資源， * 否則被其他執行緒競爭到了，當前執行緒需要進入AQS的同步佇列 * 對於嘗試修改state的值的執行緒可以同時是多個， * 他們之間沒有先後順序，這也是非公平的重要體現 */ if (compareAndSetState(0, acquires)) { /** * 當前執行緒已經持有鎖了，設定鎖的佔有者 */ setExclusiveOwnerThread(current); return true; } } /** * 如果持有鎖的執行緒是當前執行緒，可以繼續嘗試獲取鎖 * 這也是可重入的重要體現 */ else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; /** * state是int型別，也就是可重入次數不能低於Integer.MAX_VALUE */ if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); /** * 獲取鎖以後直接設定state的值 */ setState(nextc); return true; } /** * 如果一個執行緒既不是第一次獲取鎖，又不是已經獲取鎖， * 則該執行緒無法獲取鎖，需要進入AQS的同步佇列排隊 */ return false; } protected final boolean tryRelease(int releases) { /** * 計算釋放releases個資源後state的值 */ int c = getState() - releases; /** * 持有鎖的執行緒如果不是當前執行緒，無法釋放資源 */ if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; /** * 當所有的資源全部釋放掉（c=0）時，鎖的持有者需要設定為null， * 讓後續執行緒可以來競爭鎖 */ if (c == 0) { free = true; setExclusiveOwnerThread(null); } /** * 修改state的狀態 */ setState(c); return free; } protected final boolean isHeldExclusively() { /** * 當前執行緒是否持有鎖 */ return getExclusiveOwnerThread() == Thread.currentThread(); } ``` ### ReentrantLock.NonfairSync類原始碼解析 ``` static final class NonfairSync extends Sync { /** * 非公平鎖，對外獲取鎖的步驟： * 首先，嘗試修改state的狀態（從0修改成1），如果修改成功說明當前沒有任何執行緒持有鎖 * 如果執行緒獲取到鎖，則把鎖的持有執行緒設定為當前執行緒 * 如果無法獲取鎖，說明鎖已經被執行緒持有，有兩種情況： * 情況1：持有鎖的執行緒是當前執行緒，可以走可重入的流程 * 情況2：持有鎖的執行緒不是當前執行緒，需要進入AQS去排隊 */ final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); } /** * 嘗試快速獲取鎖 */ protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); } } ``` ### ReentrantLock.FairSync類原始碼解析 ``` static final class FairSync extends Sync { /** * 阻塞方式獲取鎖 */ final void lock() { acquire(1); } /** * 嘗試獲取公平鎖，與上面分析的nonfairTryAcquire方法很類似， * 重點描述彼此之間的區別 */ protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { /** * 公平鎖與非公平鎖很大的一個區別是： * 在嘗試獲取鎖的時候，如果AQS的同步佇列中有其他執行緒在等待獲取鎖 * 則嘗試獲取鎖失敗，需要進入AQS的同步佇列排隊 * hasQueuedPredecessors方法判斷AQS的同步佇列是否有執行緒在等待 */ 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; } } ``` ### ReentrantLock類原始碼解析 `ReentrantLock`類的實現方式比較簡單，主要是依靠`NonfairSync`和`FairSync`實現的功能 ``` public class ReentrantLock implements Lock, java.io.Serializable { private final Sync sync; /** * 預設是非公平鎖 */ public ReentrantLock() { sync = new NonfairSync(); } /** * 獲取鎖，獲取的時候申請1個資源 */ public void lock() { sync.lock(); } /** * 可中斷的方式獲取鎖 */ public void lockInterruptibly() throws InterruptedException { sync.acquireInterruptibly(1); } /** * * 嘗試獲取鎖，公平鎖和非公平鎖都是直接去嘗試獲取鎖 * 一般在使用該方法的時候，如果嘗試獲取鎖失敗，會有後續操作， * 可能是直接呼叫lock以阻塞的方式來獲取鎖 */ public boolean tryLock() { return sync.nonfairTryAcquire(1); } /** * 帶有超時時間的方式嘗試獲取鎖 */ public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { return sync.tryAcquireNanos(1, unit.toNanos(timeout)); } /** * 釋放鎖，釋放掉1個資源 */ public void unlock() { sync.release(1); } } ``` ## 小結 + 對於已經持有鎖的執行緒，優先申請到資源 + 對與沒有持有鎖的執行緒，需要等待持有鎖的執行緒釋放掉所有資源，包括可重入時申請到的資源 + 公平鎖在申請資源的時候要先檢查AQS同步佇列中是否有等待的執行緒，也就執行緒獲取鎖是按照FIFO