Java鎖機(jī)制淺析：到底什么情況下該用ReentrantLock？
在多線(xiàn)程編程中，鎖（Lock）是一種重要的同步機(jī)制，它可以保證同一時(shí)間只有一個(gè)線(xiàn)程可以訪(fǎng)問(wèn)共享資源。Java 中提供了兩種類(lèi)型的鎖：隱式鎖和顯式鎖。
隱式鎖通過(guò) synchronized 關(guān)鍵字實(shí)現(xiàn)，在使用時(shí)比較方便，但其粒度較大，無(wú)法滿(mǎn)足復(fù)雜的同步需求。而顯式鎖則通過(guò) Lock 接口實(shí)現(xiàn)，可以更靈活地控制鎖的粒度和行為。本文將介紹 Java 顯式鎖中的顯示鎖（ReentrantLock）和顯示條件隊(duì)列（Condition），并討論它們的使用方法、進(jìn)階用法以及可能遇到的問(wèn)題和解決方案。
一、顯示鎖
1、簡(jiǎn)介
顯示鎖（ReentrantLock）是 Java 顯式鎖中最常用的一種，它實(shí)現(xiàn)了 Lock 接口的所有特性，并提供了可重入和公平性等額外功能。其中，可重入指同一線(xiàn)程可以多次獲取該鎖而不會(huì)造成死鎖，公平性指多個(gè)線(xiàn)程按照申請(qǐng)鎖的順序獲得鎖。
與隱式鎖不同的是，顯示鎖需要手動(dòng)加鎖和釋放鎖，通常使用 try-finally 語(yǔ)句塊保證鎖的正確釋放，避免異常導(dǎo)致鎖未能被及時(shí)釋放而造成死鎖。
2、基本使用
顯示鎖（ReentrantLock）的基本用法如下：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private final Lock lock = new ReentrantLock();
private int count = 0;
public void run() {
lock.lock(); // 加鎖
try {
count++; // 訪(fǎng)問(wèn)共享資源
} finally {
lock.unlock(); // 解鎖
}
}
}在上述示例中，我們首先創(chuàng)建了一個(gè) ReentrantLock 對(duì)象，并將其作為同步對(duì)象（Monitor）來(lái)訪(fǎng)問(wèn)共享資源。然后，在訪(fǎng)問(wèn)共享資源時(shí)使用 lock.lock() 方法加鎖，使用 lock.unlock() 方法解鎖。由于 lock 和 unlock 方法都可能拋出異常，因此通常需要使用 try-finally 語(yǔ)句塊來(lái)確保鎖的正確釋放。
3、可重入性
在 Java 中，可重入性指同一線(xiàn)程可以多次獲得該鎖而不會(huì)產(chǎn)生死鎖或排斥自己的情況。這是由于每個(gè)線(xiàn)程在加鎖時(shí)會(huì)記錄加鎖的次數(shù)，只有在解鎖和加鎖次數(shù)相等時(shí)才真正釋放鎖。例如：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private final Lock lock = new ReentrantLock();
private int count = 0;
public void run() {
lock.lock(); // 第一次加鎖
try {
count++; // 訪(fǎng)問(wèn)共享資源
lock.lock(); // 第二次加鎖
try {
count++; // 訪(fǎng)問(wèn)共享資源
} finally {
lock.unlock(); // 第二次解鎖
}
} finally {
lock.unlock(); // 第一次解鎖
}
}
}在上述示例中，我們先后兩次獲取了同一個(gè)鎖，并在其中訪(fǎng)問(wèn)了共享資源。由于鎖是可重入的，因此即使在第二次加鎖時(shí)仍然持有鎖，也不會(huì)產(chǎn)生死鎖或排斥自己的情況。
4、公平性
在 Java 中，公平性指多個(gè)線(xiàn)程按照申請(qǐng)鎖的順序獲得鎖的特性。公平性可以避免某些線(xiàn)程長(zhǎng)期持有鎖，導(dǎo)致其他線(xiàn)程無(wú)法獲得鎖而等待過(guò)長(zhǎng)時(shí)間的情況。
在顯示鎖中，默認(rèn)情況下是非公平的，即當(dāng)前線(xiàn)程可以隨時(shí)獲得鎖，而不考慮其他線(xiàn)程的申請(qǐng)順序。這樣可能會(huì)導(dǎo)致某些線(xiàn)程一直無(wú)法獲得鎖，從而產(chǎn)生線(xiàn)程饑餓（Thread Starvation）的問(wèn)題。
為了解決這個(gè)問(wèn)題，Java 中提供了公平鎖（FairLock），它會(huì)按照線(xiàn)程申請(qǐng)鎖的順序進(jìn)行排隊(duì)，并且保證先來(lái)先得的原則。示例代碼如下：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private final Lock lock = new ReentrantLock(true); // 公平鎖
private int count = 0;
public void run() {
lock.lock(); // 加鎖
try {
count++; // 訪(fǎng)問(wèn)共享資源
} finally {
lock.unlock(); // 解鎖
}
}
}在上述示例中，我們創(chuàng)建了一個(gè)公平鎖（FairLock），并將其傳遞給 ReentrantLock 的構(gòu)造函數(shù)中。然后，在訪(fǎng)問(wèn)共享資源時(shí)使用 lock.lock() 方法加鎖，使用 lock.unlock() 方法解鎖。由于公平鎖會(huì)按照線(xiàn)程申請(qǐng)鎖的順序進(jìn)行排隊(duì)，因此可以避免線(xiàn)程饑餓的問(wèn)題。
二、顯示條件隊(duì)列
1、簡(jiǎn)介
條件隊(duì)列（Condition）是 Java 顯式鎖中實(shí)現(xiàn)線(xiàn)程等待/通知機(jī)制的一種方式。它允許多個(gè)線(xiàn)程在某些條件不滿(mǎn)足時(shí)暫停執(zhí)行，并在特定條件滿(mǎn)足時(shí)恢復(fù)執(zhí)行。與 synchronized 關(guān)鍵字相比，條件隊(duì)列提供了更靈活和細(xì)粒度的同步控制，可以更好地支持復(fù)雜的同步需求。
條件隊(duì)列通常與顯示鎖一起使用，通過(guò)
ReentrantLock.newCondition() 方法創(chuàng)建一個(gè) Condition 對(duì)象，并使用 await()、signal() 和 signalAll() 等方法來(lái)進(jìn)行線(xiàn)程等待和喚醒操作。其中，await() 方法用于使當(dāng)前線(xiàn)程等待某個(gè)條件發(fā)生變化，signal() 方法用于喚醒一個(gè)等待該條件的線(xiàn)程，signalAll() 方法用于喚醒所有等待該條件的線(xiàn)程。
2、基本使用
顯示條件隊(duì)列（Condition）的基本用法如下：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private final Lock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();
private boolean flag = false;
public void run() {
lock.lock(); // 加鎖
try {
while (!flag) {
condition.await(); // 等待條件變化
}
// 訪(fǎng)問(wèn)共享資源
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock(); // 解鎖
}
}
public void changeFlag() {
lock.lock(); // 加鎖
try {
flag = true; // 修改條件
condition.signalAll(); // 喚醒等待的線(xiàn)程
} finally {
lock.unlock(); // 解鎖
}
}
}在上述示例中，我們首先創(chuàng)建了一個(gè) Condition 對(duì)象，并將其關(guān)聯(lián)到一個(gè)顯示鎖（ReentrantLock）上。然后，在訪(fǎng)問(wèn)共享資源時(shí)使用 while 循環(huán)判斷條件是否滿(mǎn)足，如果不滿(mǎn)足則調(diào)用 condition.await() 方法使當(dāng)前線(xiàn)程進(jìn)入等待狀態(tài)。在修改條件時(shí)調(diào)用 changeFlag() 方法，并使用 condition.signalAll() 喚醒所有等待該條件的線(xiàn)程。需要注意的是，await() 方法和 signal()/signalAll() 方法都必須在鎖保護(hù)下進(jìn)行調(diào)用，否則會(huì)拋出
IllegalMonitorStateException 異常。
3、進(jìn)階使用
條件隊(duì)列（Condition）還提供了許多高級(jí)操作，用于支持更復(fù)雜的同步需求。以下是一些常用的進(jìn)階使用方式：
（1）等待超時(shí)
有時(shí)候我們希望線(xiàn)程在等待一段時(shí)間后自動(dòng)喚醒，而不是一直等待到被喚醒為止。這時(shí)候可以使用 condition.await(long time, TimeUnit unit) 方法，它允許我們指定等待的最長(zhǎng)時(shí)間，如果超過(guò)指定時(shí)間仍未被喚醒，則自動(dòng)退出等待狀態(tài)。示例代碼如下：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;
public class MyRunnable implements Runnable {
private final Lock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();
private boolean flag = false;
public void run() {
lock.lock(); // 加鎖
try {
long timeout = 10L; // 等待 10 秒
while (!flag) {
if (!condition.await(timeout, TimeUnit.SECONDS)) {
// 在等待一定時(shí)間后還未被喚醒，做相應(yīng)處理
break;
}
}
// 訪(fǎng)問(wèn)共享資源
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock(); // 解鎖
}
}
public void changeFlag() {
lock.lock(); // 加鎖
try {
flag = true; // 修改條件
condition.signalAll(); // 喚醒等待的線(xiàn)程
} finally {
lock.unlock(); // 解鎖
}
}
}在上述示例中，我們使用 condition.await(timeout, TimeUnit.SECONDS) 方法等待了 10 秒，如果超過(guò)該時(shí)間還未被喚醒，則退出等待狀態(tài)并做相應(yīng)處理。
（2）等待多個(gè)條件
有時(shí)候我們需要等待多個(gè)條件同時(shí)滿(mǎn)足后才能繼續(xù)執(zhí)行，這時(shí)候可以使用多個(gè)條件隊(duì)列（Condition）來(lái)實(shí)現(xiàn)。示例代碼如下：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private final Lock lock = new ReentrantLock();
private final Condition condition1 = lock.newCondition();
private final Condition condition2 = lock.newCondition();
private boolean flag1 = false;
private boolean flag2 = false;
public void run() {
lock.lock(); // 加鎖
try {
while (!flag1 || !flag2) {
if (!flag1) {
condition1.await(); // 等待條件 1
}
if (!flag2) {
condition2.await(); // 等待條件 2
}
}
// 訪(fǎng)問(wèn)共享資源
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock(); // 解鎖
}
}
public void changeFlag1() {
lock.lock(); // 加鎖
try {
flag1 = true; // 修改條件 1
condition1.signalAll(); // 喚醒等待條件 1 的線(xiàn)程
} finally {
lock.unlock(); // 解鎖
}
}
public void changeFlag2() {
lock.lock(); // 加鎖
try {
flag2 = true; // 修改條件 2
condition2.signalAll(); // 喚醒等待條件 2 的線(xiàn)程
} finally {
lock.unlock(); // 解鎖
}
}
}在上述示例中，我們創(chuàng)建了兩個(gè)條件隊(duì)列（Condition），分別用于等待兩個(gè)不同的條件。然后，在訪(fǎng)問(wèn)共享資源時(shí)使用 while 循環(huán)判斷兩個(gè)條件是否都滿(mǎn)足，如果不滿(mǎn)足則分別調(diào)用 condition1.await() 和 condition2.await() 方法使當(dāng)前線(xiàn)程進(jìn)入等待狀態(tài)。在修改條件時(shí)分別調(diào)用 changeFlag1() 和 changeFlag2() 方法，并使用 condition1.signalAll() 和 condition2.signalAll() 喚醒等待相應(yīng)條件的線(xiàn)程。
（3）實(shí)現(xiàn)生產(chǎn)者消費(fèi)者模型
條件隊(duì)列（Condition）還可以用于實(shí)現(xiàn)生產(chǎn)者消費(fèi)者模型，其中生產(chǎn)者和消費(fèi)者共享一個(gè)緩沖區(qū)，當(dāng)緩沖區(qū)為空時(shí)，消費(fèi)者需要等待生產(chǎn)者生產(chǎn)數(shù)據(jù)；當(dāng)緩沖區(qū)滿(mǎn)時(shí)，生產(chǎn)者需要等待消費(fèi)者消費(fèi)數(shù)據(jù)。示例代碼如下：
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private final Lock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
private final Queue<Integer> queue = new LinkedList<>();
private final int maxSize = 10;
public void run() {
while (true) {
lock.lock(); // 加鎖
try {
while (queue.isEmpty()) {
notEmpty.await(); // 等待不為空
}
int data = queue.poll(); // 取出數(shù)據(jù)
notFull.signalAll(); // 喚醒生產(chǎn)者
// 處理數(shù)據(jù)
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock(); // 解鎖
}
}
}
public void produce(int data) {
lock.lock(); // 加鎖
try {
while (queue.size() == maxSize) {
notFull.await(); // 等待不滿(mǎn)
}
queue.offer(data); // 添加數(shù)據(jù)
notEmpty.signalAll(); // 喚醒消費(fèi)者
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock(); // 解鎖
}
}
}在上述示例中，我們創(chuàng)建了一個(gè)緩沖區(qū)（Queue），并使用兩個(gè)條件隊(duì)列（Condition）分別表示緩沖區(qū)不為空和不滿(mǎn)。在消費(fèi)者線(xiàn)程中，使用 while 循環(huán)判斷緩沖區(qū)是否為空，如果為空則調(diào)用 notEmpty.await() 方法使當(dāng)前線(xiàn)程進(jìn)入等待狀態(tài)。當(dāng)從緩沖區(qū)取出數(shù)據(jù)后，調(diào)用 notFull.signalAll() 方法喚醒所有等待不滿(mǎn)的生產(chǎn)者線(xiàn)程。在生產(chǎn)者線(xiàn)程中，使用 while 循環(huán)判斷緩沖區(qū)是否已滿(mǎn)，如果已滿(mǎn)則調(diào)用 notFull.await() 方法使當(dāng)前線(xiàn)程進(jìn)入等待狀態(tài)。當(dāng)往緩沖區(qū)添加數(shù)據(jù)后，調(diào)用 notEmpty.signalAll() 方法喚醒所有等待不為空的消費(fèi)者線(xiàn)程。
三、讀寫(xiě)鎖
1、簡(jiǎn)介
讀寫(xiě)鎖是一種特殊的鎖，它允許多個(gè)線(xiàn)程同時(shí)讀取共享資源，但只允許一個(gè)線(xiàn)程對(duì)共享資源進(jìn)行寫(xiě)操作。讀寫(xiě)鎖可以有效地提高并發(fā)性能，特別是在讀取操作遠(yuǎn)多于寫(xiě)操作的場(chǎng)景下。
Java 中提供了 ReentrantReadWriteLock 類(lèi)來(lái)實(shí)現(xiàn)讀寫(xiě)鎖。它包含一個(gè)讀鎖和一個(gè)寫(xiě)鎖，讀鎖可同時(shí)被多個(gè)線(xiàn)程持有，但寫(xiě)鎖一次只能被一個(gè)線(xiàn)程持有。示例代碼如下：
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class MyRunnable implements Runnable {
private final ReadWriteLock lock = new ReentrantReadWriteLock();
private int count = 0;
public void run() {
lock.readLock().lock(); // 獲取讀鎖
try {
// 訪(fǎng)問(wèn)共享資源（讀取）
} finally {
lock.readLock().unlock(); // 釋放讀鎖
}
}
public void write() {
lock.writeLock().lock(); // 獲取寫(xiě)鎖
try {
// 訪(fǎng)問(wèn)共享資源（寫(xiě)入）
} finally {
lock.writeLock().unlock(); // 釋放寫(xiě)鎖
}
}
}在上述示例中，我們創(chuàng)建了一個(gè)讀寫(xiě)鎖（ReentrantReadWriteLock），并使用 readLock() 方法獲取讀鎖，writeLock() 方法獲取寫(xiě)鎖。在訪(fǎng)問(wèn)共享資源時(shí)，讀取操作可以同時(shí)被多個(gè)線(xiàn)程持有讀鎖，而寫(xiě)入操作必須先獲取寫(xiě)鎖，然后其他所有操作都被阻塞，直到寫(xiě)入完成并釋放寫(xiě)鎖。
2、使用場(chǎng)景
讀寫(xiě)鎖適用于以下場(chǎng)景：
- 讀取操作遠(yuǎn)多于寫(xiě)入操作。
- 共享資源的狀態(tài)不會(huì)發(fā)生太大變化，即讀取操作和寫(xiě)入操作之間的時(shí)間間隔較長(zhǎng)。
- 寫(xiě)入操作對(duì)資源的一致性要求高，需要獨(dú)占式訪(fǎng)問(wèn)。
使用讀寫(xiě)鎖可以有效地提高程序的并發(fā)性能，特別是在讀取操作遠(yuǎn)多于寫(xiě)入操作的情況下。但需要注意的是，讀寫(xiě)鎖的實(shí)現(xiàn)需要消耗更多的系統(tǒng)資源，因此只有在讀取操作遠(yuǎn)多于寫(xiě)入操作、且讀寫(xiě)操作之間的時(shí)間間隔較長(zhǎng)時(shí)才應(yīng)該使用讀寫(xiě)鎖。
四、StampedLock
1、簡(jiǎn)介
StampedLock 是 Java 8 新增的一種鎖機(jī)制，它是對(duì)讀寫(xiě)鎖的一種改進(jìn)，具有更高的并發(fā)性能。StampedLock 支持三種模式：讀（共享）、寫(xiě)（獨(dú)占）和樂(lè)觀(guān)讀（非獨(dú)占）。與 ReadWriteLock 不同的是，StampedLock 的讀取操作不會(huì)被阻塞，但可能會(huì)失敗，如果讀取的數(shù)據(jù)在讀取過(guò)程中發(fā)生了改變，則讀取操作會(huì)失敗并返回一個(gè)標(biāo)記（stamp），此時(shí)可以根據(jù)需要重試讀取操作或者轉(zhuǎn)換為獨(dú)占寫(xiě)入操作。
StampedLock 使用一個(gè)長(zhǎng)整型的 stamp 來(lái)表示鎖的版本號(hào)，每次修改數(shù)據(jù)后都會(huì)更新版本號(hào)。讀取操作需要傳入當(dāng)前版本號(hào)以確保讀取的數(shù)據(jù)沒(méi)有被修改，寫(xiě)入操作則需要傳入上一次讀取操作返回的版本號(hào)以確保數(shù)據(jù)的一致性。示例代碼如下：
import java.util.concurrent.locks.StampedLock;
public class MyRunnable implements Runnable {
private final StampedLock lock = new StampedLock();
private int x = 0;
private int y = 0;
public void run() {
long stamp = lock.tryOptimisticRead(); // 嘗試樂(lè)觀(guān)讀取
int currentX = x;
int currentY = y;
if (!lock.validate(stamp)) { // 校驗(yàn)版本號(hào)
stamp = lock.readLock(); // 獲取讀鎖
try {
currentX = x; // 重新讀取數(shù)據(jù)
currentY = y;
} finally {
lock.unlockRead(stamp); // 釋放讀鎖
}
}
// 訪(fǎng)問(wèn)共享資源（讀取）
}
public void write(int newX, int newY) {
long stamp = lock.writeLock(); // 獲取寫(xiě)鎖
try {
x = newX; // 修改數(shù)據(jù)
y = newY;
} finally {
lock.unlockWrite(stamp); // 釋放寫(xiě)鎖
}
}
}在上述示例中，我們創(chuàng)建了一個(gè) StampedLock，并使用 tryOptimisticRead() 方法嘗試進(jìn)行樂(lè)觀(guān)讀取操作。如果校驗(yàn)版本號(hào)失敗，則說(shuō)明數(shù)據(jù)被修改過(guò)，此時(shí)需要再次獲取讀鎖并重新讀取數(shù)據(jù)。在修改數(shù)據(jù)時(shí)，使用 writeLock() 方法獲取寫(xiě)鎖，修改完成后釋放寫(xiě)鎖。
2、使用場(chǎng)景
StampedLock 適用于以下場(chǎng)景：
- 讀取操作頻繁，而寫(xiě)入操作較少。
- 數(shù)據(jù)的一致性要求不高，即數(shù)據(jù)會(huì)發(fā)生周期
性的變化，但讀取操作與寫(xiě)入操作之間的時(shí)間間隔較短，不需要使用分布式鎖或者數(shù)據(jù)庫(kù)事務(wù)來(lái)保證數(shù)據(jù)一致性。
使用 StampedLock 可以提高程序的并發(fā)性能，特別是在讀取操作頻繁、寫(xiě)入操作較少的情況下。但需要注意的是，StampedLock 的實(shí)現(xiàn)依賴(lài)于硬件的 CAS（Compare and Swap）指令，因此在某些 CPU 架構(gòu)上可能會(huì)存在性能問(wèn)題。此外，在使用樂(lè)觀(guān)讀取模式時(shí)需要進(jìn)行版本號(hào)校驗(yàn)，如果校驗(yàn)失敗則需要重新獲取讀鎖并重新讀取數(shù)據(jù)，這可能會(huì)帶來(lái)額外的開(kāi)銷(xiāo)和復(fù)雜度。
五、總結(jié)
Java 提供了多種鎖機(jī)制來(lái)協(xié)調(diào)多個(gè)線(xiàn)程對(duì)共享資源的訪(fǎng)問(wèn)。ReentrantLock 是最基本的一種鎖，它采用獨(dú)占式訪(fǎng)問(wèn)方式，可以精確控制多個(gè)線(xiàn)程對(duì)共享資源的訪(fǎng)問(wèn)順序。Condition 可以用于在鎖的基礎(chǔ)上實(shí)現(xiàn)更靈活的同步操作，例如線(xiàn)程的等待和喚醒。ReadWriteLock 是一種特殊的鎖，它允許多個(gè)線(xiàn)程同時(shí)讀取共享資源，但只允許一個(gè)線(xiàn)程對(duì)共享資源進(jìn)行寫(xiě)操作。StampedLock 是對(duì)讀寫(xiě)鎖的一種改進(jìn)，具有更高的并發(fā)性能，但需要注意的是它的實(shí)現(xiàn)依賴(lài)于硬件的 CAS 指令。
在使用鎖時(shí)需要注意避免死鎖、避免過(guò)度競(jìng)爭(zhēng)和防止資源饑餓等問(wèn)題。應(yīng)該根據(jù)具體的場(chǎng)景選擇不同的鎖機(jī)制，并合理地設(shè)置鎖的粒度和范圍。同時(shí)也可以考慮使用一些高級(jí)的并發(fā)工具來(lái)簡(jiǎn)化鎖的管理，例如 Executor 框架、原子變量、信號(hào)量、倒計(jì)時(shí)門(mén)閂等。
