ReentrantLock

目錄

• 公平方式獲取鎖
• 非公平方式獲取鎖
• 釋放鎖

上一篇分享了AQS的基本原理：AQS（AbstractQueuedSynchronizer），在此基礎上，再來看看ReentrantLock對AQS是怎麼實現的，尤爲是對可重入以及公平和非公平的理解

公平方式獲取鎖

先看看lock()方法：

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

/**
*對AQS中對應方法的重寫，位於FairSync類中，鎖公平獲取實現方式
*/
protected final boolean tryAcquire(int acquires) {//acquires=1
            final Thread current = Thread.currentThread();//獲取當前線程
            int c = getState();//獲取AQS中state的值，0表示資源未被佔用，既沒有線程獲取到鎖
            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;
        }

大概流程：

1. 若是沒有線程獲取到鎖：
   若是當前線程的節點在等待隊列裏面沒有有效的前驅結點（體現公平性），就去以原子方式將state置爲1，而且把持有鎖的線程設置成本身，返回true（獲取鎖成功）；
2. 若是有線程已經獲取了鎖而且拿到鎖的線程就是當前線程：
   AQS中的state+1，返回true（獲取鎖成功）；
3. 當上述兩個步驟沒成功執行則返回false（獲取鎖失敗）；

主要再來看一下hasQueuedPredecessors()：

/**
*判斷隊列裏面有沒有比當前線程等待更久更先到等待隊列的線程，越靠近head越優先獲取鎖即先到先得（公平性）
*/
public final boolean hasQueuedPredecessors() {
        Node t = tail;
        Node h = head;//當前已經得到鎖的線程節點
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

非公平方式獲取鎖

先來看看lock()方法：

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

和公平方式不一樣的是，他會先嚐試把state設置成1，若是設置成功，那就把持有鎖的線程設置爲本身，不然纔去正常獲取鎖。
再看他對tryAcquire的重寫：

protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }

/**
*非公平方式獲取鎖
*/
final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
            //該步驟相似於上面lock()方法的第一步
                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;
        }

1. 若是當前所沒有被佔用，則本身以「惡霸」的形式直接佔用該鎖；
2. 若是本身以前已經拿到了鎖，此次重入就將state+1；

釋放鎖

public void unlock() {
        sync.release(1);
    }

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

1. 先給state-1；
2. 若是當前線程沒持有鎖，就拋異常；
3. 若是state在修改以後等於0，就說明鎖已經被徹底釋放；
4. 注意，該方法返回的是鎖有沒有被徹底釋放。