@[TOC]

前言

了解ReentrantLock的原理和底層實(shí)現(xiàn)

一庭呜、ReentrantLock是如何實(shí)現(xiàn)的？

ReentrantLock 主要利用CAS 和 AQS隊(duì)列實(shí)現(xiàn)，并且支持公平鎖和非公平鎖猬腰。

CAS：Compare and Swap际起，比較并交換。在java中雁乡，CAS主要由Unsafe類通過JIN調(diào)用CPU底層代碼實(shí)現(xiàn)第喳。

CAS有三個參數(shù)：內(nèi)存值V、預(yù)期值A(chǔ)踱稍、新值B曲饱。當(dāng)且僅當(dāng)，預(yù)期值A(chǔ)和內(nèi)存值V相同時珠月，將內(nèi)存值修改為B渔工，否則不做修改。

關(guān)于AQS桥温，參見文章AQS隊(duì)列

二引矩、lock 和 unlock的過程分析

2.1 ReentrantLock的兩個構(gòu)造器

public ReentrantLock() {
        sync = new NonfairSync();
    }
public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

默認(rèn)構(gòu)造器會將其實(shí)例化為NonfairSync對象，即非公平鎖侵浸，而帶參數(shù)的構(gòu)造器可以指定使用公平鎖還是非公平鎖旺韭。

2.2 lock過程

NonfairSync.lock

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

非公平鎖的lock方法中，首先是一個CAS操作掏觉，判斷state是否是0区端，即當(dāng)前鎖是否被其他線程占用了；如果是0澳腹，則設(shè)置為1织盼，且設(shè)置當(dāng)前線程為獨(dú)占線程。這里CAS操作避免了并發(fā)操作的問題酱塔。

這里也是第一處體現(xiàn)非公平鎖：如果此處占用鎖的線程剛剛好釋放鎖沥邻，則當(dāng)前線程可以直接獲取鎖，而無需排隊(duì)羊娃，相當(dāng)于直接“插隊(duì)”唐全。

若此處沒有設(shè)置成功，即沒有獲取鎖蕊玷，則會執(zhí)行acquire()方法邮利。
acquire()

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

第一步是調(diào)用tryAcquire()方法弥雹，嘗試獲取鎖。

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) { //狀態(tài)為0延届，沒有線程占用鎖
                if (compareAndSetState(0, acquires)) {
                    //與lock方法里一樣剪勿，直接獲取鎖
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) { // 當(dāng)前線程已經(jīng)占用該鎖
                int nextc = c + acquires; // 鎖重入次數(shù)
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false; // 獲取鎖失敗，返回false
        }

這里第二次體現(xiàn)了不公平鎖方庭。

這里還檢驗(yàn)了是不是當(dāng)前線程已經(jīng)獲取鎖窗宦，而又重新獲取鎖。這里體現(xiàn)了重入鎖二鳄。會更新狀態(tài)值為重入的次數(shù)赴涵。

第二步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;
    }

這個添加到隊(duì)列的方法在上篇文章AQS已經(jīng)分析過了订讼，就不詳細(xì)分析了髓窜。

第三步acquireQueued()，此方法是讓隊(duì)列中的線程嘗試獲取鎖欺殿，如果失敗則掛起線程寄纵。

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true; // 標(biāo)記是否獲取鎖成功
        try {
            boolean interrupted = false; // 線程中斷標(biāo)志
            for (;;) {  // 自旋
                final Node p = node.predecessor();  // 獲得前驅(qū)節(jié)點(diǎn)
                // 如果該節(jié)點(diǎn)的前驅(qū)節(jié)點(diǎn)是head，則該節(jié)點(diǎn)是隊(duì)列中的第一個線程脖苏，可以嘗試互毆去鎖
                if (p == head && tryAcquire(arg)) { 
                    setHead(node); // 獲取鎖成功
                    p.next = null; // help GC程拭，不然GC無法回收
                    failed = false; // 獲取鎖成功
                    return interrupted; //返回中斷標(biāo)志，沒有被中斷
                }
                // 如果獲取失敗棍潘，是否可以掛起
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node); // 最后取消嘗試獲取鎖
        }
    }

當(dāng)上述方法獲取鎖失敗之后恃鞋，就會判斷線程是否需要掛起。下面說明下shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()方法亦歉。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        // 前驅(qū)節(jié)點(diǎn)的狀態(tài)
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true; // 如果前驅(qū)節(jié)點(diǎn)狀態(tài)是SIGNAL恤浪，則返回true，可以掛起
        // 前驅(qū)節(jié)點(diǎn)是CANCELLED
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            // 從隊(duì)尾向前循環(huán)查找肴楷，直到找到第一個不為CANCELLED的節(jié)點(diǎn)
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            // 設(shè)置前驅(qū)節(jié)點(diǎn)狀態(tài)為SIGNAL
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
 // 掛起當(dāng)前線程水由，并返回線程中斷狀態(tài)
 private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

這里解釋下，線程掛起的前提是赛蔫，前驅(qū)節(jié)點(diǎn)是SIGNAL狀態(tài)砂客。那SIGNAL狀態(tài)的含義是什么？SIGNAL表示其前驅(qū)節(jié)點(diǎn)線程如果獲取鎖呵恢，退出隊(duì)列鞠值，則將其喚醒。

2.3 unlock過程

unlock

public void unlock() {
        sync.release(1);
    }
public final boolean release(int arg) {
        if (tryRelease(arg)) { // 嘗試釋放鎖
            Node h = head; // 獲取頭節(jié)點(diǎn)
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h); // 如果頭節(jié)點(diǎn)不為空且不為狀態(tài)不為0瑰剃，則取消掛起
            return true; // 釋放成功
        }
        return false; // 釋放失敗
    }

這里先嘗試釋放鎖齿诉，如果成功筝野，就將頭節(jié)點(diǎn)取消掛起晌姚。

tryRealase

protected final boolean tryRelease(int releases) {
            // 當(dāng)前鎖狀態(tài)值減去釋放值粤剧，注意考慮重入鎖，不是直接置為0
            int c = getState() - releases;
            // 如果不是當(dāng)前線程占用鎖挥唠，則拋出異常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) { // 如果狀態(tài)值等于0抵恋，則釋放鎖成功
                free = true;
                // 清空獨(dú)占線程
                setExclusiveOwnerThread(null);
            }
            // 更新state 值
            setState(c);
            return free;
        }

三、公平鎖和非公平鎖的區(qū)別

下面介紹非公平鎖和公平鎖的區(qū)別宝磨，公平鎖在獲取鎖之前弧关，不會直接CAS去獲取鎖，而是先判斷當(dāng)前鎖狀態(tài)是不是等于0且當(dāng)前線程是不是隊(duì)列中第一個線程唤锉，state=0才去嘗試獲得鎖世囊。

protected final boolean tryAcquire(int acquires) {
            // 獲取當(dāng)前線程
            final Thread current = Thread.currentThread();
            // 獲取鎖狀態(tài)
            int c = getState();
            if (c == 0) { // 如果鎖沒有被任何線程擁有
                // 當(dāng)前線程是CLH隊(duì)列的的第一個線程，則取獲取鎖
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
            //如果當(dāng)前線程已經(jīng)獲得獨(dú)占鎖窿祥，則進(jìn)行狀態(tài)更新
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

四株憾、Synchronized和ReentrantLock的區(qū)別

4.1 功能區(qū)別

Synchronized是Java語言的關(guān)鍵字，是通過JVM實(shí)現(xiàn)的晒衩。

ReentrantLock是API層面的一種互斥鎖嗤瞎，而且它的鎖粒度和靈活性都優(yōu)于Synchronized。

Synchronized使用較為簡單方便听系，由編譯器去保證鎖的加鎖和釋放贝奇。而ReentrantLock需要手動加鎖和釋放鎖，如果忘記手工釋放鎖靠胜，會造成死鎖掉瞳。

4.2 性能區(qū)別

在Synchronized優(yōu)化之前，性能是比較差的浪漠，因?yàn)槎际侵亓考夋i菠赚。但是Synchronized引入偏向鎖，輕量級鎖之后郑藏，兩者的性能相差不大衡查。當(dāng)不需要使用ReentrantLock的特有性質(zhì)時，官方建議使用Synchronized必盖。

4.3 ReentrantLock的特有性質(zhì)

等待可中斷：持有鎖的線程長期不釋放的時候拌牲，正在等待的線程可以選擇放棄等待，這相當(dāng)于Synchronized來說可以避免出現(xiàn)死鎖的情況歌粥。通過lock.lockInterruptibly()來實(shí)現(xiàn)這個機(jī)制塌忽。

公平鎖：多個線程等待同一個鎖時，必須按照申請鎖的時間順序獲得鎖失驶，Synchronized鎖是非公平鎖土居，ReentrantLock可以實(shí)現(xiàn)公平鎖。

選擇性通知（鎖綁定多個條件）：一個ReentrantLock可以同時綁定多個對象，然后通過condition（條件）類擦耀，來分組喚醒線程棉圈，而Synchronized是隨機(jī)喚醒一個線程或者所有線程。

ReentrantLock原理詳解