快捷導(dǎo)航

詳解java并發(fā)之重入鎖-ReentrantLock

更新時間：2019年03月13日 15:37:27 作者：胖虎。。

這篇文章主要介紹了java并發(fā)之重入鎖-ReentrantLock，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

前言

目前主流的鎖有兩種，一種是synchronized，另一種就是ReentrantLock，JDK優(yōu)化到現(xiàn)在目前為止synchronized的性能已經(jīng)和重入鎖不分伯仲了，但是重入鎖的功能和靈活性要比這個關(guān)鍵字多的多，所以重入鎖是可以完全替代synchronized關(guān)鍵字的。下面就來介紹這個重入鎖。

正文

ReentrantLock重入鎖是Lock接口里最重要的實現(xiàn)，也是在實際開發(fā)中應(yīng)用最多的一個，我這篇文章更接近實際開發(fā)的應(yīng)用場景，為開發(fā)者提供直接上手應(yīng)用。所以不是所有方法我都講解，有些冷門的方法我不會介紹或一句帶過。

一、首先先看聲明一個重入鎖需要使用到那幾個構(gòu)造方法

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

推薦聲明方式

private static ReentrantLock lock = new ReentrantLock(true);
private static ReentrantLock locka = new ReentrantLock();

重點說明：

ReentrantLock提供了兩個構(gòu)造方法，對應(yīng)兩種聲明方式。

第一種聲明的是公平鎖，所謂公平鎖，就是按照時間先后順序，使先等待的線程先得到鎖，而且，公平鎖不會產(chǎn)生饑餓鎖，也就是只要排隊等待，最終能等待到獲取鎖的機會。

第二種聲明的是非公平鎖，所謂非公平鎖就和公平鎖概念相反，線程等待的順序并不一定是執(zhí)行的順序，也就是后來進來的線程可能先被執(zhí)行。

ReentrantLock默認是非公平鎖，因為：公平鎖實現(xiàn)了先進先出的公平性，但是由于來一個線程就加入隊列中，往往都需要阻塞，再由阻塞變?yōu)檫\行，這種上下文切換是非常好性能的。非公平鎖由于允許插隊所以，上下文切換少的多，性能比較好，保證的大的吞吐量，但是容易出現(xiàn)饑餓問題。所以實際生產(chǎn)也是較多的使用非公平鎖。

非公平鎖調(diào)用的是NonfairSync方法。

二、加入鎖之后lock方法到底是怎么處理的（只講非公平鎖）
剛才我們說如果是非公平鎖就調(diào)用NonfairSync方法，那我們就來看看這個方法都做來什么。

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
 
        /**
         * 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);
        }
 
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

重點說明：

讀前先知：ReentrantLock用state表示“持有鎖的線程已經(jīng)重復(fù)獲取該鎖的次數(shù)”。當state（下文用狀態(tài)二子代替）等于0時，表示當前沒有線程持有鎖）。
第一步調(diào)用compareAndSetState方法，傳了第一參數(shù)是期望值0，第二個參數(shù)是實際值1，當前這個方法實際是調(diào)用了unsafe.compareAndSwapInt實現(xiàn)CAS操作的，也就是上鎖之前狀態(tài)必須是0，如果是0調(diào)用setExclusiveOwnerThread方法

private transient Thread exclusiveOwnerThread;
 
    
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

可以看出setExclusiveOwnerThread就是線程設(shè)置為當前線程，此時說明有一名線程已經(jīng)拿到了鎖。大家都是CAS有三個值，如果舊值等于預(yù)期值，就把新值賦予上，所以當前線程得到了鎖就會把狀態(tài)置為1。

第二步是compareAndSetState方法返回false時，此時調(diào)用的是acquire方法，參數(shù)傳1

tryAcquire（）方法實際是調(diào)用了nonfairTryAcquire（）方法。

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
 
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;
        }

注釋上說的很明白，請求獨占鎖，忽略所有中斷，至少執(zhí)行一次tryAcquire，如果成功就返回，否則線程進入阻塞--喚醒兩種狀態(tài)切換中，直到tryAcquire成功。詳情見鏈接tryAcquire()、addWaiter()、acquireQueued()挨個分析。

好，到日前為止大家清楚了lock（）方法到調(diào)用過程，清楚了，為什么只有得到鎖的當前線程才可以執(zhí)行，沒有得到的會在隊列里不停的利用CAS原理試圖得到鎖，CAS很高效，也就是，為什么ReentrantLock比synchronized高效的原因，缺點是很浪費cpu資源。

三、所有線程都執(zhí)行完畢后調(diào)用unlock（）方法

unlock()方法是通過AQS的release(int)方法實現(xiàn)的，我們可以看一下：

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

tryRelease()是由子類實現(xiàn)的，我們來看一下ReentrantLock中的Sync對它的實現(xiàn)：

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

先通過getState獲得狀態(tài)標識，如果這個標識和要釋放的數(shù)量相等，就會把當前占有鎖的線程設(shè)置為null，實現(xiàn)鎖的釋放，然后返回true，否則把狀態(tài)標識減去releases再返回false。

以上所述是小編給大家介紹的java并發(fā)之重入鎖-ReentrantLock詳解整合，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復(fù)大家的。在此也非常感謝大家對腳本之家網(wǎng)站的支持！

您可能感興趣的文章: