Java并發(fā)中ReentrantLock鎖怎么用

這篇文章主要講解了“Java并發(fā)中ReentrantLock鎖怎么用”，文中的講解內(nèi)容簡單清晰，易于學(xué)習(xí)與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學(xué)習(xí)“Java并發(fā)中ReentrantLock鎖怎么用”吧！

重入鎖可以替代關(guān)鍵字 synchronized 。

在 JDK5.0 的早期版本中，重入鎖的性能遠(yuǎn)遠(yuǎn)優(yōu)于關(guān)鍵字 synchronized ，

但從 JDK6.0 開始， JDK 在關(guān)鍵字 synchronized 上做了大量的優(yōu)化，使得兩者的性能差距并不大。

重入鎖使用 ReentrantLock 實(shí)現(xiàn)

1、重入鎖

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();
    public static int i = 0;

    @Override
    public void run() {
        for (int j = 0; j < 10000000; j++) {
            lock.lock();
            lock.lock();
            try {
                i++;
            } finally {
                lock.unlock();
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockDemo tl = new ReentrantLockDemo();
        Thread t1 = new Thread(tl);
        Thread t2 = new Thread(tl);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

控制臺打印

20000000

說明

一個(gè)線程連續(xù)兩次獲得同一把鎖是允許的。

如果不允許這么操作，那么同一個(gè)線程在第 2 次獲得鎖時(shí)，將會和自己產(chǎn)生死鎖。

程序就會“卡死”在第 2 次申請鎖的過程中。

但需要注意的是，如果同一個(gè)線程多次獲得鎖，那么在釋放鎖的時(shí)候，也必須釋放相同次數(shù)。

如果釋放鎖的次數(shù)多了，那么會得到一個(gè) java.lang.IllegalMonitorStateException 異常，反之，如果釋放鎖的次數(shù)少了，那么相當(dāng)于線程還持有這個(gè)鎖，因此，其他線程也無法進(jìn)入臨界區(qū)。

2、中斷響應(yīng)

對于關(guān)鍵字 synchronized 來說，如果一個(gè)線程在等待鎖，那么結(jié)果只有兩種情況，要么它獲得這把鎖繼續(xù)執(zhí)行，要么它就保持等待。

而使用重入鎖，則提供另外一種可能，那就是線程可以被中斷。

也就是在等待鎖的過程中，程序可以根據(jù)需要取消對鎖的請求。

有些時(shí)候，這么做是非常有必要的。

比如，你和朋友約好一起去打球，如果你等了半個(gè)小時(shí)朋友還沒有到，你突然接到一個(gè)電話，說由于突發(fā)情況，朋友不能如約前來了，那么你一定掃興地打道回府了。

中斷正是提供了一套類似的機(jī)制。

如果一個(gè)線程正在等待鎖，那么它依然可以收到一個(gè)通知，被告知無須等待，可以停止工作了。

這種情況對于處理死鎖是有一定幫助的。

下面的代碼產(chǎn)生了一個(gè)死鎖，但得益于鎖中斷，我們可以很輕易地解決這個(gè)死鎖。

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.locks.ReentrantLock;

public class IntLock implements Runnable {
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;

    /**
     * 控制加鎖順序，方便構(gòu)造死鎖
     *
     * @param lock
     */
    public IntLock(int lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            if (lock == 1) {
                lock1.lockInterruptibly();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock2.lockInterruptibly();
            } else {
                lock2.lockInterruptibly();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock1.lockInterruptibly();
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock1.isHeldByCurrentThread())
                lock1.unlock();
            if (lock2.isHeldByCurrentThread())
                lock2.unlock();
            System.out.println(Thread.currentThread().getId() + ":線程退出");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        IntLock r1 = new IntLock(1);
        IntLock r2 = new IntLock(2);
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        //中斷其中一個(gè)線程
        t2.interrupt();
    }
}

控制臺輸出

java.lang.InterruptedException

at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)

at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)

at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)

at com.shockang.study.java.concurrent.lock.IntLock.run(IntLock.java:35)

at java.lang.Thread.run(Thread.java:748)

11:線程退出

12:線程退出

說明

線程 t1 和 t2 啟動(dòng)后， t1 先占用 lock1 ，再占用 lock2。

t2 先占用 lock2 ，再請求 lock1。

因此，很容易形成 t1 和 t2 之間的相互等待。

在這里，對鎖的請求，統(tǒng)一使用 lockInterruptibly() 方法。

這是一個(gè)可以對中斷進(jìn)行響應(yīng)的鎖申請動(dòng)作，即在等待鎖的過程中，可以響應(yīng)中斷。

在代碼第 56 行，主線程 main 處于休眠狀態(tài)，此時(shí)，這兩個(gè)線程處于死鎖的狀態(tài)。

在代碼第 58 行，由于 t2 線程被中斷，故 t2 會放棄對 lock1 的申請，同時(shí)釋放已獲得的 lock2 。

這個(gè)操作導(dǎo)致 t1 線程可以順利得到 lock2 而繼續(xù)執(zhí)行下去。

3、鎖申請等待限時(shí)

除了等待外部通知之外，要避免死鎖還有另外一種方法，那就是限時(shí)等待。

依然以約朋友打球?yàn)槔绻笥淹送瞬粊?，又無法聯(lián)系到他，那么在等待 1 到 2 個(gè)小時(shí)后，我想大部分人都會掃興離去。

對線程來說也是這樣。

通常，我們無法判斷為什么一個(gè)線程退遲拿不到鎖。

也許是因?yàn)樗梨i了，也許是因?yàn)楫a(chǎn)生了饑餓。

如果給定一個(gè)等待時(shí)間，讓線程自動(dòng)放棄，那么對系統(tǒng)來說是有意義的。

我們可以使用 tryLock() 方法進(jìn)行一次限時(shí)的等待。

tryLock(long, TimeUnit)

下面這段代碼展示了限時(shí)等待鎖的使用。

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TimeLock implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            if (lock.tryLock(5, TimeUnit.SECONDS)) {
                Thread.sleep(6000);
            } else {
                System.out.println("get lock failed");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        TimeLock tl = new TimeLock();
        Thread t1 = new Thread(tl);
        Thread t2 = new Thread(tl);
        t1.start();
        t2.start();
    }
}

控制臺打印

get lock failed
Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
at com.shockang.study.java.concurrent.lock.TimeLock.run(TimeLock.java:20)
at java.lang.Thread.run(Thread.java:748)

說明

在這里， tryLock() 方法接收兩個(gè)參數(shù)，一個(gè)表示等待時(shí)長，另外一個(gè)表示計(jì)時(shí)單位。

這里的單位設(shè)置為秒，時(shí)長為 5 ，表示線程在這個(gè)鎖請求中最多等待 5 秒。

如果超過 5 秒還沒有得到鎖，就會返回 false 。

如果成功獲得鎖，則返回 true 。

在本例中，由于占用鎖的線程會持有鎖長達(dá) 6 秒，故另一個(gè)線程無法在 5 秒的等待時(shí)間內(nèi)獲得鎖，因此請求鎖會失敗。

tryLock()

ReentrantLock.tryLock() 方法也可以不帶參數(shù)直接運(yùn)行。

在這種情況下，當(dāng)前線程會嘗試獲得鎖，如果鎖并未被其他線程占用，則申請鎖會成功，并立即返回 true 。

如果鎖被其他線程占用，則當(dāng)前線程不會進(jìn)行等待，而是立即返回 false 。

這種模式不會引起線程等待，因此也不會產(chǎn)生死鎖。

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.locks.ReentrantLock;

public class TryLock implements Runnable {
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;

    public TryLock(int lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        if (lock == 1) {
            while (true) {
                if (lock1.tryLock()) {
                    try {
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                        }
                        if (lock2.tryLock()) {
                            try {
                                System.out.println(Thread.currentThread()
                                        .getId() + ":My Job done");
                                return;
                            } finally {
                                lock2.unlock();
                            }
                        }
                    } finally {
                        lock1.unlock();
                    }
                }
            }
        } else {
            while (true) {
                if (lock2.tryLock()) {
                    try {
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                        }
                        if (lock1.tryLock()) {
                            try {
                                System.out.println(Thread.currentThread()
                                        .getId() + ":My Job done");
                                return;
                            } finally {
                                lock1.unlock();
                            }
                        }
                    } finally {
                        lock2.unlock();
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TryLock r1 = new TryLock(1);
        TryLock r2 = new TryLock(2);
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
    }
}

控制臺輸出

11:My Job done
12:My Job done

說明

上述代碼采用了非常容易死鎖的加鎖順序。

也就是先讓 t1 獲得 lock1 ，再讓 2 獲得 lock2 ，接著做反向請求，讓 t1 申請 lock2 ， t2 申請 lock1 。

在一般情況下，這會導(dǎo)致 t1 和 2 相互等待。

待，從而引起死鎖。

但是使用 tryLock() 方法后，這種情況就大大改善了。

由于線程不會傻傻地等待，而是不停地嘗試，因此，只要執(zhí)行足夠長的時(shí)間，線程總是會得到所有需要的資源，從而正常執(zhí)行(這里以線程同時(shí)獲得 lock1 和 lock2 兩把鎖，作為其可以正常執(zhí)行的條件)。

在同時(shí)獲得 lock1 和 lock2 后，線程就打印出標(biāo)志著任務(wù)完成的信息“ My Job done”。

4、公平鎖

在大多數(shù)情況下，鎖的申請都是非公平的。

也就是說，線程 1 首先請求了鎖 A ，接著線程 2 也請求了鎖 A 。

那么當(dāng)鎖 A 可用時(shí)，是線程 1 可以獲得鎖還是線程 2 可以獲得鎖呢？

這是不一定的，系統(tǒng)只是會從這個(gè)鎖的等待隊(duì)列中隨機(jī)挑選一個(gè)。

因此不能保證其公平性。

這就好比買票不排隊(duì)，大家都圍在售票窗口前，售票員忙得焦頭爛額，也顧不及誰先誰后，隨便找個(gè)人出票就完事了。

而公平的鎖，則不是這樣，它會按照時(shí)間的先后順序，保證先到者先得，后到者后得。

公平鎖的一大特點(diǎn)是:它不會產(chǎn)生饑餓現(xiàn)象。

關(guān)于線程饑餓請參考我的博客——死鎖、活鎖和饑餓是什么意思？

只要你排隊(duì)，最終還是可以等到資源的。

如果我們使用 synchronized 關(guān)鍵字進(jìn)行鎖控制，那么產(chǎn)生的鎖就是非公平的。

而重入鎖允許我們對其公平性進(jìn)行設(shè)置。

它的構(gòu)造函數(shù)如下：

/**
 * 使用給定的公平策略創(chuàng)建一個(gè) ReentrantLock 的實(shí)例。
 *
 * @param fair 如果此鎖應(yīng)使用公平排序策略為 true
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

當(dāng)參數(shù) fair 為 true 時(shí)，表示鎖是公平的。

公平鎖看起來很優(yōu)美，但是要實(shí)現(xiàn)公平鎖必然要求系統(tǒng)維護(hù)一個(gè)有序隊(duì)列，因此公平鎖的實(shí)現(xiàn)成本比較高，性能卻非常低下，因此，在默認(rèn)情況下，鎖是非公平的。

如果沒有特別的需求，則不需要使用公平鎖。

公平鎖和非公平鎖在線程調(diào)度表現(xiàn)上也是非常不一樣的。

下面的代碼可以很好地突出公平鎖的特點(diǎn)。

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.locks.ReentrantLock;

public class FairLock implements Runnable {
    public static ReentrantLock fairLock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true) {
            try {
                fairLock.lock();
                System.out.println(Thread.currentThread().getName() + " 獲得鎖");
            } finally {
                fairLock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        FairLock r1 = new FairLock();
        Thread t1 = new Thread(r1, "Thread_t1");
        Thread t2 = new Thread(r1, "Thread_t2");
        t1.start();
        t2.start();
    }
}

控制臺輸出

獲得鎖

Thread_t2 獲得鎖

Thread_t2 獲得鎖

Thread_t2 獲得鎖

Thread_t2 獲得鎖

Thread_t1 獲得鎖

Thread_t1 獲得鎖

Thread_t2 獲得鎖

Thread_t2 獲得鎖

Thread_t2 獲得鎖

Thread_t1 獲得鎖

Thread_t1 獲得鎖

# 省略

說明

由于代碼會產(chǎn)生大量輸出，這里只截取部分進(jìn)行說明。

在這個(gè)輸出中，很明顯可以看到，兩個(gè)線程基本上是交替獲得鎖的，幾乎不會發(fā)生同一個(gè)線程連續(xù)多次獲得鎖的可能，從而保證了公平性。

如果設(shè)置了 false，則會根據(jù)系統(tǒng)的調(diào)度，一個(gè)線程會傾向于再次獲取已經(jīng)持有的鎖，這種分配方式是高效的，但是無公平性可言。

源碼（JDK8）

/**
 * 一種可重入互斥鎖，其基本行為和語義與使用同步方法和語句訪問的隱式監(jiān)視鎖（即 synchronized）相同，但具有擴(kuò)展功能。 
 * 
 * 可重入鎖屬于上次成功鎖定但尚未解鎖它的線程。
 * 
 * 當(dāng)鎖不屬于另一個(gè)線程時(shí)，調(diào)用鎖的線程將返回，并成功獲取鎖。
 * 
 * 如果當(dāng)前線程已經(jīng)擁有鎖，則該方法將立即返回。這可以使用 isHeldByCurrentThread 和 getHoldCount 方法進(jìn)行檢查。 
 * 
 * 此類的構(gòu)造函數(shù)接受可選的公平性參數(shù)。
 * 
 * 當(dāng)設(shè)置為 true 時(shí)，在競爭狀態(tài)下，鎖有利于向等待時(shí)間最長的線程授予訪問權(quán)限。否則，此鎖不保證任何特定的訪問順序。
 * 
 * 使用由多線程訪問的公平鎖的程序可能顯示較低的總吞吐量
 * 
 * （即，較慢；通常比使用默認(rèn)設(shè)置的要慢得多，但是在獲得鎖和保證不饑餓的時(shí)間上有較小的差異。
 * 
 * 但是請注意，鎖的公平性并不能保證線程調(diào)度的公平性。
 * 
 * 因此，使用公平鎖的多個(gè)線程中的一個(gè)線程可以連續(xù)多次獲得公平鎖，而其他活動(dòng)線程則沒有進(jìn)行并且當(dāng)前沒有持有該鎖。
 * 
 * 還要注意，untimed tryLock() 方法不支持公平性設(shè)置。
 * 
 * 如果鎖可用，即使其他線程正在等待，它也會成功。 
 * 
 * 建議的做法是總是在調(diào)用之后立即使用try塊鎖定，最典型的是在構(gòu)建之前/之后，例如：
 * 
 * class X {
 *   private final ReentrantLock lock = new ReentrantLock();
 *   // ...
 *
 *   public void m() {
 *     lock.lock();  // block until condition holds
 *     try {
 *       // ... method body
 *     } finally {
 *       lock.unlock()
 *     }
 *   }
 * }}
 * 
 * 除了實(shí)現(xiàn)鎖接口之外，這個(gè)類還定義了許多公共和受保護(hù)的方法來檢查鎖的狀態(tài)。
 * 
 * 其中一些方法只對 instrumentation 和 monitoring 有用。 
 * 
 * 此類的序列化與內(nèi)置鎖的行為相同：反序列化的鎖處于未鎖定狀態(tài)，而與序列化時(shí)的狀態(tài)無關(guān)。 
 * 
 * 此鎖最多支持同一線程的2147483647個(gè)遞歸鎖。嘗試超過此限制會導(dǎo)致鎖定方法拋出錯(cuò)誤。
 * 
 * @since 1.5
 * @author Doug Lea
 */
public class ReentrantLock implements Lock, java.io.Serializable

感謝各位的閱讀，以上就是“Java并發(fā)中ReentrantLock鎖怎么用”的內(nèi)容了，經(jīng)過本文的學(xué)習(xí)后，相信大家對Java并發(fā)中ReentrantLock鎖怎么用這一問題有了更深刻的體會，具體使用情況還需要大家實(shí)踐驗(yàn)證。這里是億速云，小編將為大家推送更多相關(guān)知識點(diǎn)的文章，歡迎關(guān)注！