ReentrantLock 是java繼synchronized關鍵字之後新出的執行緒鎖，今天看了看實現原始碼。主要是通過自旋來實現的。使用自旋的基本思路就是為所有的執行緒構建一個node，連成一個佇列，然後每一個node都輪詢前驅節點，如果前驅已經釋放鎖了，那麼當前階段就可以獲取鎖，否則就繼續迴圈。

之前瞭解過使用ThreadLocal機制實現的自旋鎖，但是reentrant lock應該是另一種。

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
 

這是加鎖方法，先進行一次快速加鎖，失敗了再進行常規加鎖。快速加鎖的情景指的是當前沒有鎖，所以直接CAS原子操作看看能不能獲取，也就是if塊裡的操作，如果沒有成功，常規獲取，也就是acquire操作。

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

首先執行一次tryAcquire（）嘗試獲取，分為公平和非公平，這裡就只看非公平的情況吧

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

首先獲取當前執行緒，然後得到鎖此時的state，如果state是0，說明可以爭取鎖，CAS一下，否則說明鎖被用了，但是如果用鎖的就是當前執行緒，就把state加1，獲取成功，否則就獲取失敗。

一旦tryAcquire（）返回了false，說明獲取鎖失敗了，就必須進入等待佇列中，所以會執行後面的acquireQueued（addWaiter）方法。先看addWaiter

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

addWaiter所做的是把當前執行緒加入到等待佇列中，也就是把鎖的tail變數設定為當前執行緒，也是先快設定一次，也就是一次CAS，如果成功就返回，否則就執行一次常規加入，即enq操作

private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

enq就是典型的自旋+CAS的實現，因為CAS控制併發是非阻塞的，所以如果一定要讓操作執行，必須把CAS放入迴圈內。所以enq就是一個while迴圈，不斷檢測CAS是否成功

一旦加入隊列了，剩下的就是執行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);
        }
    }

可以看到，確實有一個迴圈，不斷檢測前驅節點，如果前驅是head（這是一個dump頭節點），說明自己已經是真正的頭節點了，可以互獲鎖了，就會持續執行tryAcquire去競爭。這個佇列的消費是直接把消費的節點從佇列刪除，而之前部落格的CLH是通過節點的一個狀態字來檢測的。

可以看到，整個重入鎖就是通過自旋+CAS來實現的

獲取鎖的大致過程如下：

執行一次CAS獲取，若不成功則

執行一次tryAcquire獲取，若不成功則

把當前節點加入到佇列，也是先CAS加入一次，不成功再自旋

自旋檢測前驅是否釋放鎖，並嘗試獲取

與自旋鎖相對應的概念是互斥鎖，等待時是通過讓執行緒睡眠實現的。自旋鎖適用於佔用鎖時間比較短的場景，這樣執行緒狀態轉換的開銷相比較與cpu迴圈，代價會變大，但是隨著鎖獲取時間的增長，cpu的代價會越來越大