ReentrantLock的實作原理介紹（程式碼範例）

這篇文章帶給大家的內容是關於ReentrantLock的實現原理介紹（程式碼範例），有一定的參考價值，有需要的朋友可以參考一下，希望對你有幫助。

在並發程式設計中，除了synchronized關鍵字，java並發套件中java.util.concurrent.locks中的ReentrantLock和ReentrantReadWriteLock也是常用的鎖定實作。本篇從原始碼方面，分析一下重入鎖ReentrantLock的原理。

先說一下什麼的重入鎖：某個執行緒取得鎖以後，還可以多次重複取得鎖，不會自己阻塞自己。

ReentrantLock是基於抽象類別AbstractQueuedSynchronizer（以下簡稱AQS）實作。

看原始碼：

首先從建構器可以看出，ReentrantLock有公平鎖和非公平鎖兩種機制。

//默认非公平锁
public ReentrantLock() {
        sync = new NonfairSync();
    }

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

先簡單說明公平鎖定和非公平鎖定的區別，然後在分析兩者的不同實現方式。

公平鎖定：多個執行緒之間講究先來後到。類似排隊，後面來的線程依序排在佇列最後。

非公平鎖定：進行鎖的爭搶。搶到就執行，沒搶到就阻塞。等待獲得鎖的線程釋放後，再參與競爭。

所以通常使用非公平鎖。其效率比公平鎖高。

取得鎖定

公平鎖定

#

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

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

　　第一步tryAcquire(arg)嘗試加入鎖，由FairSync實現，具體程式碼如下：

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中的state。如果state為0，表示此時沒有執行緒獲得鎖。　　

• 在if判斷中，先判斷AQS的Node佇列是否為空。如果不是空的，就需要排隊。此時不取得鎖。

• 嘗試使用CAS演算法，將state更新為1。更新成功，取得鎖，將此時的執行緒設定為獨佔執行緒exclusiveOwnerThread。傳回true。

• 如果state不為0，表示已經有執行緒獲得了鎖定。所以要判斷獲得鎖的線程（獨佔線程）是否為當前線程。

• 如果是，表示是重入情況。將state增加1。傳回true。

• 走到最後一步，就是沒有獲得鎖定了。傳回false；

　　繼續上面的步驟，如果取得鎖定失敗，先執行addWaiter(Node.EXCLUSIVE)，將目前執行緒寫入佇列

#

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

• 封裝一個新節點node

• #判斷鍊錶尾是否為空，不是就把新節點node'寫入最後

• '鍊錶尾為空，則以enq(node)寫入最後。

　　寫入佇列以後，acquireQueued()方法，掛起目前執行緒。

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

• 在循環中，如果node的上一個是頭節點，則再嘗試取得鎖定。成功就結束循環，回傳false

• 不是頭節點，就根據上一個節點的waitStatus，判斷是否需要掛起目前執行緒。 waitStatus用來記錄節點狀態，如節點取消，節點等待等。

• 判斷需要掛起，則使用parkAndCheckInterrupt()方法，並掛起執行緒。具體使用LockSupport.park(this)掛起執行緒。

• 如果在這裡的第一步就取得鎖定成功了，就可以取消此節點的取得鎖定操作了。

非公平鎖定

　　非公平鎖定在鎖的取得策略上有差異。

final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
 protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }

• 非公平鎖定先直接嘗試使用CAS演算法更新state，取得鎖定

• # #更新失敗以後，在嘗試取得鎖定

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

#與公平鎖定相比，非公平鎖定嘗試取得鎖定的過程中，無需判斷隊列中是否存在其他執行緒。

釋放鎖定

公平鎖定和非公平鎖定釋放鎖定的步驟都一樣

public void unlock() {
        sync.release(1);
    }
public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
//更新state
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;
        }

值得注意的是，因為是重入鎖的關係，在tryRelease()方法中，需要將state更新為0，才認為完全釋放鎖定。釋放以後，再喚醒掛起執行緒。

以上是ReentrantLock的實作原理介紹（程式碼範例）的詳細內容。更多資訊請關注PHP中文網其他相關文章！