深刻淺出ReentrantLock源碼解析

ReentrantLock不可是可重入鎖，並且仍是公平或非公平鎖，在工做中會常用到，將本身對這兩種鎖的理解記錄下來，但願對你們有幫助。

前提條件

在理解ReentrantLock時須要具有一些基本的知識

理解AQS的實現原理

以前有寫過一篇《深刻淺出AQS源碼解析》關於AQS的文章，對AQS原理不瞭解的同窗能夠先看一下

什麼是可重入鎖

當一個線程已經持有鎖，若是該如今再次獲取鎖，是否能夠獲取成功？若是能獲取成功則說明該鎖是可重入的，不然是不可重入的

什麼是公平鎖和非公平鎖

公平與非公平的一個很本質的區別就是，是否遵照FIFO（也就是先來後到）。當有多個線程來申請鎖的時候，是否先申請的線程先獲取鎖，後申請的線程後獲取鎖？若是是的，則是公平鎖，不然是非公平鎖。

更準確地說，先申請鎖的線程先得到鎖競爭的權利。對於公平的排他鎖而言，先申請鎖的線程會先獲取鎖，可是對於公平的共享鎖而言，先申請鎖的線程會先擁有獲取鎖競爭的權利，其餘等待共享鎖的線程也會被喚醒，有可能後喚醒的線程先獲取鎖。

ReentrantLock 源碼解析

ReentrantLock的功能主要是經過3個內部類Sync、FairSync和NonfairSync來實現的，這3個內部類繼承了AbstractQueuedSynchronizer，其中FairSync和NonfairSync類繼承了Sync，接下來咱們一一解讀這幾個內部類。

ReentrantLock.Sync類源碼解析

因爲ReentrantLock.Sync類中的核心代碼比較少，原理也比較簡單，因此就直接在代碼中經過詳細註釋的方式來解讀

abstract static class Sync extends AbstractQueuedSynchronizer {

    /**
     * 定義了一個抽象方法，用來獲取鎖
     */
    abstract void lock();

    /**
     * NonfairSync中tryAcquire和、ReentrantLock.tryLock會使用到
     * 重要功能：快速嘗試獲取鎖，若是可以獲取鎖返回true，不然返回false
     * 在嘗試獲取鎖的過程當中，不會阻塞當前線程，通常狀況下是當前線程已經持有鎖時
     * 纔有多是能夠直接獲取鎖，這也是可重入功能的核心實現
     */
    final boolean nonfairTryAcquire(int acquires) {
        // 獲取當前線程
        final Thread current = Thread.currentThread();
        /**
         * state是AQS對外提供的一個變量，讓不一樣的實現類能夠經過這個變量
         * 來控制鎖被線程獲取鎖的次數
         */
        int c = getState();
        // 當state爲0表示該鎖是沒有被任何線程持有
        if (c == 0) {
           /**
            * CAS操做若是成功，說明當前線程競爭到了鎖資源，
            * 不然被其餘線程競爭到了，當前線程須要進入AQS的同步隊列
            * 對於嘗試修改state的值的線程能夠同時是多個，
            * 他們之間沒有前後順序，這也是非公平的重要體現
            */
            if (compareAndSetState(0, acquires)) {
              /**
                * 當前線程已經持有鎖了，設置鎖的佔有者
                */
                setExclusiveOwnerThread(current);
                return true;
            }
        }
      /**
        * 若是持有鎖的線程是當前線程，能夠繼續嘗試獲取鎖
        * 這也是可重入的重要體現
        */
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
           /**
            * state是int類型，也就是可重入次數不能低於Integer.MAX_VALUE
            */
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
           /**
            * 獲取鎖之後直接設置state的值
            */
            setState(nextc);
            return true;
        }
       /**
        * 若是一個線程既不是第一次獲取鎖，又不是已經獲取鎖，
        * 則該線程沒法獲取鎖，須要進入AQS的同步隊列排隊
        */
        return false;
    }

    protected final boolean tryRelease(int releases) {
       /**
        * 計算釋放releases個資源後state的值
        */
        int c = getState() - releases;
       /**
        * 持有鎖的線程若是不是當前線程，沒法釋放資源
        */
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
       /**
        * 當全部的資源所有釋放掉（c=0）時，鎖的持有者須要設置爲null，
        * 讓後續線程能夠來競爭鎖
        */
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
       /**
        * 修改state的狀態
        */
        setState(c);
        return free;
    }

    protected final boolean isHeldExclusively() {
        /**
        * 當前線程是否持有鎖
        */
        return getExclusiveOwnerThread() == Thread.currentThread();
    }

ReentrantLock.NonfairSync類源碼解析

static final class NonfairSync extends Sync {
    /**
     * 非公平鎖，對外獲取鎖的步驟：
     * 首先，嘗試修改state的狀態（從0修改爲1），若是修改爲功說明當前沒有任何線程持有鎖
     * 若是線程獲取到鎖，則把鎖的持有線程設置爲當前線程
     * 若是沒法獲取鎖，說明鎖已經被線程持有，有兩種狀況：
     * 狀況1：持有鎖的線程是當前線程，能夠走可重入的流程
     * 狀況2：持有鎖的線程不是當前線程，須要進入AQS去排隊
     */
    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    /**
     * 嘗試快速獲取鎖
     */
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

ReentrantLock.FairSync類源碼解析

static final class FairSync extends Sync {
    /**
     * 阻塞方式獲取鎖
     */
    final void lock() {
        acquire(1);
    }

    /**
     * 嘗試獲取公平鎖，與上面分析的nonfairTryAcquire方法很相似，
     * 重點描述彼此之間的區別
     */
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            /**
             * 公平鎖與非公平鎖很大的一個區別是：
             * 在嘗試獲取鎖的時候，若是AQS的同步隊列中有其餘線程在等待獲取鎖
             * 則嘗試獲取鎖失敗，須要進入AQS的同步隊列排隊
             * hasQueuedPredecessors方法判斷AQS的同步隊列是否有線程在等待
             */
            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;
    }
}

ReentrantLock類源碼解析

ReentrantLock類的實現方式比較簡單，主要是依靠NonfairSync和FairSync實現的功能

public class ReentrantLock implements Lock, java.io.Serializable {

    private final Sync sync;

    /**
     * 默認是非公平鎖
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * 獲取鎖，獲取的時候申請1個資源
     */
    public void lock() {
        sync.lock();
    }

    /**
     * 可中斷的方式獲取鎖
     */
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    /**
     * 
     * 嘗試獲取鎖，公平鎖和非公平鎖都是直接去嘗試獲取鎖
     * 通常在使用該方法的時候，若是嘗試獲取鎖失敗，會有後續操做，
     * 多是直接調用lock以阻塞的方式來獲取鎖
     */
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

    /**
     * 帶有超時時間的方式嘗試獲取鎖
     */
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    /**
     * 釋放鎖，釋放掉1個資源
     */
    public void unlock() {
        sync.release(1);
    }
}

總結

• 對於已經持有鎖的線程，優先申請到資源
• 對與沒有持有鎖的線程，須要等待持有鎖的線程釋放掉全部資源，包括可重入時申請到的資源
• 公平鎖在申請資源的時候要先檢查AQS同步隊列中是否有等待的線程，也就線程獲取鎖是按照FIFO的方式