ReentrantLock是一個可重入鎖，意思就是說可以遞迴的呼叫鎖，而不會因為遞迴進入加鎖方法而發生死鎖，這裡後面會新增解釋 

ReentrantLock是基於AQS實現，其原理和AQS大致相同，分為公平鎖和非公平鎖，他們都會維護一個CLH雙端佇列，本質上是一

個雙端連結串列，本質上都要繼承AQS並重寫相應的方法 tryAcquire（）方法 還有tryRelease（）

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

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

 

 嘗試獲取鎖 acquire的意思是 嘗試獲取鎖tryAcquire（）方法如果返回true 說明獲取鎖成功 直接返回去執行業務程式碼 如果失敗 看下一個方法判斷acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 包裝成一個節點新增到CLH佇列中

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

如果state是0並且CLH佇列中沒有節點就嘗試做CAS更改state的值得操作 返回true 執行業務程式碼 要求提現了公平性，排隊佇列的特性 如果不符合 ok 看下一條

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

 

包裝成節點先一次嘗試新增到CLH佇列中去 如果不成功 操作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;
            }
        }
    }
}

自旋CAS併發處理的新增到CLH佇列中去 

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

新增到佇列中去了 要對節點做相應的處理 會嘗試喚醒節點 如果有方法呼叫了release方法 那麼就會喚醒重新開始自旋CAS 如果是頭結點的下一個節點 就可以嘗試獲得鎖 

解鎖 

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

喚醒節點 本質上是喚醒h節點的下一個節點 

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

只有state等於0的時候才會返回true 意味著這是可重入鎖 可以多次加鎖 最後也需要多次解鎖 直到state等於0 

private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}

解鎖後一個節點 如果不成功（每一個節點都有多種狀態 可能被取消）就從最後一個節點開始往前遍歷做喚醒才做

LockSupport.unpark(s.thread);

喚醒後

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

喚醒的節點會在自旋CAS中又嘗試獲取鎖 

非公平鎖不同

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

先去搶先CAS改值 體現了搶佔式 非公平 不理會CLH佇列情況 其他的和公平鎖差不多了