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，才認為完全釋放鎖。釋放以后，再喚醒掛起線程。