ReentrantLock實現原理

陽光、大地和詩歌發表於2019-01-30
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，才認為完全釋放鎖。釋放以後，再喚醒掛起執行緒。

相關文章