ReentrantLock可重入鎖——原始碼詳解

酒冽發表於2021-12-23

開始這篇部落格之前，博主預設大家都是看過AQS原始碼的~什麼居然沒看過?猛戳下方???
全網最詳細的AbstractQueuedSynchronizer(AQS)原始碼剖析（一）AQS基礎
 全網最詳細的AbstractQueuedSynchronizer(AQS)原始碼剖析（二）資源的獲取和釋放
 全網最詳細的AbstractQueuedSynchronizer(AQS)原始碼剖析（三）條件變數

介紹

ReentrantLock是可重入鎖，是JUC提供的一種最常用的鎖。“可重入”的意思就是：同一個執行緒可以無條件地反覆獲得已經持有的鎖

ReentrantLock有公平鎖和非公平鎖兩種模式，底層使用的正是AbstractQueuedSynchronizer這個偉大的併發工具

ReentrantLock的結構如下圖所示：

ReentrantLock實現了Lock介面，該介面定義了一個鎖應該具備的基本功能，即加鎖、解鎖、建立條件變數等功能。原始碼如下：

public interface Lock {
    
    void lock();
    
    void lockInterruptibly() throws InterruptedException;
    
    boolean tryLock();
    
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    
    void unlock();
    
    Condition newCondition();
}

使用ReentrantLock，主要使用lock和unlock方法，也會用到newCondition來建立條件變數，實現一些條件同步功能

回到上面的結構圖，可以看到，ReentrantLock的功能主要是藉助其內部類Sync來實現，而Sync類是繼承了AbstractQueuedSynchronizer，並衍生出兩個子類FairSync、NonfairSync，分別對應公平鎖和非公平鎖兩種模式。實際應用中，一般非公平鎖的效率要高於公平鎖

作者：酒冽出處：https://www.cnblogs.com/frankiedyz/p/15719681.html
版權：本文版權歸作者和部落格園共有
轉載：歡迎轉載，但未經作者同意，必須保留此段宣告；必須在文章中給出原文連線；否則必究法律責任

Sync

ReentrantLock中的sync域是是一個Sync類物件，ReentrantLock使用Sync類實現主要的功能，Sync是ReentrantLock的內部類：

/** Synchronizer providing all implementation mechanics */
private final Sync sync;

Sync類繼承了AQS，使用AQS的state作為鎖的重入數，其原始碼如下：

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

    // 用於輔助ReentrantLock執行Lock介面的lock方法，所以定義了一個同名lock方法
    abstract void lock();

    // 執行非公平的tryLock，是非公平鎖子類實現的tryAcquire方法的主要邏輯，也是ReentrantLock的tryLock的主要邏輯？
    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;
    }

    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;
    }

    // 為了支援使用條件變數，Sync實現了AQS中的isHeldExclusively，並提供了newCondition方法建立條件變數
    
    protected final boolean isHeldExclusively() {
        return getExclusiveOwnerThread() == Thread.currentThread();
    }

    final ConditionObject newCondition() {
        return new ConditionObject();
    }
    
    // ReentrantLock的三個同名方法，都委託給了下面這三個方法，用於獲取鎖的一些資訊
    
    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }

    final int getHoldCount() {
        return isHeldExclusively() ? getState() : 0;
    }

    final boolean isLocked() {
        return getState() != 0;
    }

    /**
    * Reconstitutes the instance from a stream (that is, deserializes it).
    */
    private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

總結一下，Sync類有以下幾個作用：

定義抽象lock方法：Sync定義了lock這一個抽象方法，強迫兩個子類去實現，而ReentrantLock的lock方法就可以直接委託給Sync的lock方法去執行
非公平模式的嘗試獲取鎖：Sync提供了nonfairTryAcquire方法，提供非公平嘗試獲取鎖的方法。不僅非公平子類實現tryAcquire方法需要委託給nonfairTryAcquire來處理，而且ReentrantLock中的tryLock方法也會委託給它來處理
嘗試釋放鎖：Sync實現了AQS中的tryRelease方法，因為不管是公平模式還是非公平模式，釋放鎖的邏輯都是相同的，因此在Sync這一層就提供了具體的實現，而沒有下放給子類來實現
條件變數的支援：Sync實現了AQS中的isHeldExclusively方法（該方法會被AQS中的ConditionObject的signal方法呼叫），並提供了newCondition方法建立條件變數
獲取鎖資訊的方法：Sync提供了getOwner、getHoldCount、isLocked三個方法用於獲取鎖的資訊，外圍類ReentrantLock的三個同名方法會委託這三個方法來執行

獲取鎖

要利用AQS實現獲取鎖的功能，需要實現tryAcquire方法。但是由於公平模式和非公平模式下獲取鎖的邏輯不同，因此tryAcquire交給兩個子類去實現，Sync並不實現

但是對於非公平獲取鎖的模式，NonFairSync子類實現的tryAcquire方法實際上委託了Sync類的nonfairTryAcquire方法來處理。nonfairTryAcquire原始碼分析放在後面的非公平模式去講解

釋放鎖

要利用AQS實現釋放鎖的功能，需要實現tryRelease方法。不同於獲取鎖，對於公平模式和非公平模式來說，釋放鎖的邏輯是相同的，因此tryRelease的實現直接交給Sync這一層來實現，而沒有下放給子類來實現

tryRelease是嘗試釋放資源，而在ReentrantLock中的語義環境下就是嘗試釋放鎖。其原始碼如下：

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;		// 返回鎖是否空閒，如果空閒則為true
}

tryRelease的releases引數說明：
由於每次只釋放一個鎖，所以呼叫lock釋放鎖時tryRelease的releases引數恆為1
但是ReentrantLock支援條件變數，條件變數的await方法也會呼叫tryRelease方法一次性釋放所有的鎖資源，此時tryRelease的引數releases不一定為1

AQS中的release方法會呼叫tryRelease方法並接收其返回值，如下：

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

如果tryRelease返回true，說明鎖為空閒，那麼就需要喚醒等待獲取鎖而阻塞，且等待最久的執行緒，讓它來獲取鎖。因此release會喚醒同步佇列的隊首執行緒。如果鎖不是空閒，就不需要喚醒任何執行緒

非公平鎖

非公平鎖是藉助Sync和其子類NonfairSync來實現的，實現了Sync定義的lock抽象方法，以及實現了AQS中的tryAcquire方法以獲取鎖。原始碼如下：

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

    // 實現了Sync中定義的lock方法
    final void lock() {
        // 上來就CAS，一點也不客氣————非公平性
        if (compareAndSetState(0, 1))		// 如果state為0，說明鎖是空閒的，直接CAS獲取
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);	// 如果鎖不空閒，或者CAS競爭失敗，就呼叫acquire去獲取1個鎖，可能會被阻塞
    }

    // 非公平競爭鎖，實際上委託Sync.nonfairTryAcquire來執行
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

lock方法先直接CAS修改state，如果鎖空閒且修改成功，則說明獲取到了鎖，這裡也體現出非公平性，因為它不會謙讓已經在同步佇列中等待的執行緒
如果鎖非空閒或者競爭失敗，則會呼叫acquire方法。acquire會呼叫非公平鎖實現的tryAcquire方法，再次進行競爭，可能直接獲取到鎖，也可能再次失敗，進入同步佇列阻塞等待，這裡同樣體現了非公平性

公平鎖

公平鎖是藉助Sync和其子類FairSync來實現的，實現了Sync定義的lock抽象方法，以及實現了AQS中的tryAcquire方法以獲取鎖。原始碼如下：

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

    final void lock() {
        acquire(1);
    }

    // 公平競爭鎖
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            // 先檢查有無排隊等待的執行緒，如果有就不去CAS競爭——公平性
            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;
    }
}

lock方法直接呼叫acquire方法獲取鎖，而acquire會呼叫非公平鎖實現的tryAcquire方法，而tryAcquire也遵循公平性，因此該lock方法整體上就是公平的

tryAcquire方法會檢查鎖是否空閒，如果空閒，也不會立即去CAS爭奪，而是呼叫AQS的hasQueuedPredecessors方法檢查是否有執行緒在同步佇列中等待，如果沒有才會CAS競爭。如果有就說明不能競爭，返回false

AQS中的hasQueuedPredecessors方法會檢查是否有執行緒在同步佇列中等待，原始碼如下：

public final boolean hasQueuedPredecessors() {
    Node t = tail;
    Node h = head;
    Node s;
    // 如果head等於tail，說明是空佇列
    // 如果隊首的thread域不是當前執行緒，說明有別的執行緒先於當前執行緒等待獲取鎖
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

要使用公平模式的鎖，需要將`ReentrantLock`的構造引數`fair`設為true：

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

Lock介面的實現

ReentrantLock實現了Lock介面的所有方法，如下：

public void lock() {
    sync.lock();
}

public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}

public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

public void unlock() {
    sync.release(1);
}

public Condition newCondition() {
    return sync.newCondition();
}

可以看到，ReentrantLock實現的所有Lock方法其實都是委託給了Sync（AQS）來執行

ReentrantLock可重入鎖——原始碼詳解

介紹

Sync

獲取鎖

釋放鎖

非公平鎖

公平鎖

Lock介面的實現

相關面試題

相關文章