Java鎖的分類：一文列出Java常見的所有鎖，并分析其實(shí)現(xiàn)原理！
什么是鎖
鎖是一種同步機(jī)制，用于確保多線程訪問共享資源或執(zhí)行代碼塊時不發(fā)生沖突
目的：防止數(shù)據(jù)不一致或數(shù)據(jù)損壞的問題
鎖的分類
按鎖的獲取方式分類
- 內(nèi)置鎖
通過synchronized關(guān)鍵字實(shí)現(xiàn)，JVM自動管理鎖的獲取與釋放。
- 每個對象關(guān)聯(lián)一個監(jiān)視器鎖，線程進(jìn)入同步塊時自動獲取。退出時自動釋放。
特點(diǎn)：可重入、非公平、自動異常處理
底層機(jī)制：依賴對象頭中的Mark Word記錄鎖狀態(tài) - 顯式鎖
需要手動調(diào)用Lock接口的實(shí)現(xiàn)類(例如：ReentrantLock)，提供更靈活的控制
- 特點(diǎn)：支持公平鎖、可中斷、超時獲取、支持綁定多個條件變量
底層機(jī)制：基于AQS(AbstractQueuedSynchronizer)隊列同步器實(shí)現(xiàn)
按鎖的功能分類
基于多線程能否共享一把鎖，可以把鎖分為共享鎖和互斥鎖
互斥鎖(Mutual Exclusion Lock)
互斥鎖用于控制對共享資源訪問的一種同步機(jī)制，可以確保在任何給定的時間點(diǎn)上只有一個線程可以訪問特定的臨界區(qū)或共享資源。也叫排他鎖。
工作原理：互斥鎖有兩種狀態(tài)：鎖定和未鎖定。當(dāng)一個線程想要訪問受保護(hù)的資源時，必須首先嘗試獲取互斥鎖，如果此時鎖處于未鎖定狀態(tài)，則該線程可以所得鎖并繼續(xù)執(zhí)行；如果鎖已經(jīng)被其他線程持有，則當(dāng)前線程會被阻塞直到鎖釋放。
互斥鎖的特點(diǎn)：
- 原子性：獲取和釋放鎖的過程必須是原子性的，這些操作不能被打斷
- 唯一性：在同一時間點(diǎn)上，只有一個線程可以持有互斥鎖
- 可重入性：某些實(shí)現(xiàn)允許同一個線程多次獲取同一把鎖，但是必須保證每次獲取都對應(yīng)一次釋放
- 不可剝奪性：一旦一個線程獲得了互斥鎖，除非該線程主動釋放鎖，否則其他線程無法強(qiáng)制剝奪這個鎖
基于互斥鎖的特點(diǎn)，可以避免競態(tài)條件和數(shù)據(jù)不一致問題
常見的問題
- 死鎖：兩個或多個線程互相等待對方持有的資源，從而陷入永久等待狀態(tài)
- 饑餓：某些線程永遠(yuǎn)得不到執(zhí)行機(jī)會，因為其他線程總是優(yōu)先獲取所需的資源
共享鎖(Shared Lock)
共享鎖也就是讀鎖，是允許多線程共享訪問共享資源的鎖機(jī)制，主要應(yīng)用于讀多寫少的場景。通過區(qū)分讀寫操作，顯著提升并發(fā)性能。
Java中實(shí)現(xiàn)共享鎖的底層原理：【依托于AQS框架】
狀態(tài)管理：AQS使用一個32位的int變量表示鎖狀態(tài)，其中高16位記錄讀鎖的持有數(shù)量，低16位記錄寫鎖的持有數(shù)量。通過CAS操作修改state的值，確保線程安全。
讀鎖和寫鎖共享同一個CLH同步隊列，AQS通過CLH完成同步狀態(tài)的管理，若當(dāng)前線程獲取同步狀態(tài)失敗時，AQS則會將當(dāng)前線程的狀態(tài)信息構(gòu)造成一個Node節(jié)點(diǎn)，添加到CLH隊列中，并且阻塞當(dāng)前線程；當(dāng)同步狀態(tài)釋放時，會把首節(jié)點(diǎn)喚醒，使其再次嘗試獲取同步狀態(tài)
什么是CLH同步隊列？
AQS原理&CLH同步隊列
讀鎖的特點(diǎn)：
- 共享性：允許多個線程同時持有讀鎖
- 可重入性：同一線程可重復(fù)獲取讀鎖
- 與寫鎖互斥：如果當(dāng)前線程持有寫鎖，則讀鎖必須等待
public class Cache<K, V> {
private final Map<K, V> map = new HashMap<>();
private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
private final Lock readLock = rwLock.readLock();
private final Lock writeLock = rwLock.writeLock();
// 讀操作（共享鎖）
public V get(K key) {
readLock.lock();
try {
return map.get(key);
} finally {
readLock.unlock();
}
}
// 寫操作（排他鎖）
public void put(K key, V value) {
writeLock.lock();
try {
map.put(key, value);
} finally {
writeLock.unlock();
}
}
}寫鎖降級為讀鎖
鎖降級是指在持有寫鎖的情況下獲取讀鎖，隨后釋放寫鎖的過程
核心邏輯：
- 持有寫鎖：確保當(dāng)前線程獨(dú)占資源，其他線程無法讀寫
- 獲取讀鎖：在未釋放寫鎖時獲取讀鎖，防止其他線程獲取寫鎖修改數(shù)據(jù)
- 釋放寫鎖：降級為讀鎖后，允許其他線程讀取數(shù)據(jù)，但是不能寫入數(shù)據(jù)
- 釋放讀鎖：完成讀操作后釋放讀鎖，允許其他線程獲取寫鎖
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
writeLock.lock(); // 1. 獲取寫鎖
try {
// 修改共享數(shù)據(jù)
readLock.lock(); // 2. 獲取讀鎖
} finally {
writeLock.unlock(); // 3. 釋放寫鎖（此時仍持有讀鎖）
}
try {
// 讀取數(shù)據(jù)（其他線程可并發(fā)讀，但無法寫）
} finally {
readLock.unlock(); // 4. 釋放讀鎖
}為什么不支持鎖升級
鎖升級是指從讀鎖升級到寫鎖，Java中并不支持這種操作
可能產(chǎn)生的問題：
- 死鎖風(fēng)險：如果多個持有讀鎖的線程同時嘗試升級為寫鎖，會互相等待對方釋放讀鎖，這樣機(jī)會造成死鎖。
- 競爭復(fù)雜性：因為讀鎖是可重入，并且支持多個線程同時持有的，當(dāng)升級為寫鎖就會造成長時間的阻塞，等待釋放所有讀鎖
說完互斥鎖與共享鎖，接下來從線程需不需要鎖住同步資源的角度，又分為悲觀鎖和樂觀鎖
樂觀鎖(Optimistic Lock)
樂觀認(rèn)為并發(fā)沖突概率低，操作時不加鎖，只在提交時檢查數(shù)據(jù)是否被修改
實(shí)現(xiàn)方式：CAS算法和StampedLock
AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet(); // 內(nèi)部通過CAS自旋實(shí)現(xiàn)StampedLock lock = new StampedLock();
long stamp = lock.tryOptimisticRead();
// 讀取共享數(shù)據(jù)...
if (!lock.validate(stamp)) {
// 數(shù)據(jù)被修改，轉(zhuǎn)為悲觀讀鎖
stamp = lock.readLock();
// 重新讀取數(shù)據(jù)...
lock.unlockRead(stamp);
}
image.png
悲觀鎖(Pessimistic Lock)
悲觀認(rèn)為并發(fā)沖突概率高，每次訪問共享資源時，先加鎖再操作
實(shí)現(xiàn)方式：synchronized關(guān)鍵字和Lock實(shí)現(xiàn)類
image.png
適用場景：
悲觀鎖適合寫操作多的場景，先加鎖保證寫操作時數(shù)據(jù)正確
樂觀鎖適合讀操作多的場景，不加鎖的特點(diǎn)能夠大幅度提升性能
根據(jù)等待鎖的方式可分為自旋鎖和阻塞鎖
自旋鎖(Spin Lock)
當(dāng)線程嘗試獲取鎖失敗時，不會立即放棄CPU，而是通過忙循環(huán)(自旋)不斷嘗試獲取鎖，直到成功為止【默認(rèn)是循環(huán)10次】
實(shí)現(xiàn)自旋鎖的兩種方式
- 使用原子類的CAS實(shí)現(xiàn)自旋鎖--循環(huán)次數(shù)自行控制
public class SpinLock {
private AtomicBoolean locked = new AtomicBoolean(false);
public void lock() {
while (!locked.compareAndSet(false, true)) {
// 自旋等待（空循環(huán)或短暫休眠）
}
}
public void unlock() {
locked.set(false);
}
}- 使用synchronized，--循環(huán)次數(shù)默認(rèn)10次，并可以使用
-XX:PreBlockSpin修改該值
如果沒有成功獲得鎖就會將該線程掛起
自旋鎖存在的問題：
如果線程鎖在線程自旋剛結(jié)束就釋放掉鎖，那么這個線程切換上下文的代價是無端的浪費(fèi)--引出了自適應(yīng)自旋鎖
適應(yīng)型自旋鎖：自旋的次數(shù)或時間不再固定，而是由前一次在同一個鎖上的自旋時間及鎖的擁有者的狀態(tài)來決定
- 如果在同一個鎖對象上，自旋等待剛剛成功獲取過鎖，并且持有鎖的線程正在運(yùn)行中，JVM會認(rèn)為該鎖自旋獲取到鎖的可能性很大，會自動增加等待時間
- 如果對于某個鎖，自旋很少成功獲取鎖，那就會減少自旋時間或直接不自旋了，避免浪費(fèi)處理器資源
這樣的方式來實(shí)現(xiàn)動態(tài)預(yù)測自旋
image.png
阻塞鎖(Blocking Lock)
阻塞鎖是指當(dāng)線程獲取不到鎖時，不發(fā)生自旋，直接阻塞。
優(yōu)點(diǎn)：避免CPU空轉(zhuǎn)，節(jié)省資源
缺點(diǎn)：線程切換上下文帶來的額外開銷，響應(yīng)延遲較高
根據(jù)多個線程獲取同一把鎖時是否先到先得，分為公平鎖和非公平鎖
公平鎖(Fair Lock)
公平鎖是指線程獲取鎖的順序是按照線程請求鎖的時間順序來決定的【先到先得】
實(shí)現(xiàn)方式：ReentrantLock(true)
底層機(jī)制：底層維護(hù)了一個FIFO隊列，記錄等待鎖的線程；鎖釋放時，優(yōu)先喚醒隊列中的第一個線程。
image.png
非公平鎖(Non-Fair Lock)
非公平鎖是指線程獲取鎖的順序根據(jù)實(shí)際的競爭結(jié)果【誰搶到算誰的】
實(shí)現(xiàn)方式：ReentrantLock(false)或synchronized關(guān)鍵字
底層機(jī)制：新線程嘗試獲取鎖時，直接競爭，若競爭失敗再進(jìn)入隊列等待
圖片
公平鎖與非公平鎖的區(qū)別
- 公平鎖：會將所有想要獲取鎖的線程放入FIFO，這就必然會在釋放鎖時，觸發(fā)喚醒線程操作
- 非公平鎖：會直接獲取鎖，若獲取成功，則直接占用資源，無需喚醒；而獲取失敗才會到隊列排序，當(dāng)釋放鎖時，觸發(fā)喚醒線程操作
所以非公平鎖插隊失敗就是公平鎖【優(yōu)先使用非公平鎖】
根據(jù)一把鎖能否重復(fù)獲取同一把鎖，分為可重入鎖和非可重入鎖
可重入鎖(Reentrant Lock)
可重入鎖也叫遞歸鎖，是指同一個線程再外層方法獲取鎖之后，再進(jìn)入該線程的內(nèi)層方法時會自動獲取鎖
前提條件：鎖對象得是同一個對象或者Class
實(shí)現(xiàn)方式：ReentrantLock和synchronized都是可重入鎖
ReentrantLock lock = new ReentrantLock();
public void recursiveMethod(int n) {
lock.lock();
try {
if (n > 0) {
recursiveMethod(n - 1); // 遞歸調(diào)用仍可獲取鎖
}
} finally {
lock.unlock();
}
}public synchronized void methodA() {
methodB(); // 同一線程可直接進(jìn)入另一個同步方法
}
public synchronized void methodB() {}底層原理：每次獲取鎖時，內(nèi)部維護(hù)一個計數(shù)器，只要釋放鎖(unlock)就對應(yīng)減少計數(shù)器，反之增加，直到計數(shù)器歸零后完全釋放鎖
不會因為之前獲取過沒釋放而阻塞
image.png
非可重入鎖(Non-Reentrant Lock)
禁止同一線程重復(fù)獲取同一把鎖，若嘗試重復(fù)獲取，線程會立即阻塞或拋出異常
實(shí)現(xiàn)原理：
- 鎖狀態(tài)標(biāo)記：僅記錄鎖是否被占用，不跟蹤持有者
- 重復(fù)獲取行為：若線程已持有鎖，再次調(diào)用lock()會阻塞或失敗
image.png
根據(jù)在等待鎖的過程中是否可以中斷，分為可中斷鎖與不可中斷鎖
中斷鎖
線程在等待鎖時可響應(yīng)中斷
java中的中斷鎖：tryLock(time) 和 lockInterruptibly()
ReentrantLock lock = new ReentrantLock();
// 線程A獲取鎖并長期持有（同上）
new Thread(() -> {
lock.lock();
try {
Thread.sleep(10000); // 模擬長時間持有鎖
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
// 線程B嘗試獲取鎖（可中斷）
Thread threadB = new Thread(() -> {
try {
lock.lockInterruptibly(); // 可中斷的鎖請求
try {
System.out.println("ThreadB獲取鎖成功");
} finally {
lock.unlock();
}
} catch (InterruptedException e) {
System.out.println("ThreadB被中斷，退出等待");
}
});
threadB.start();
// 主線程嘗試中斷線程B
Thread.sleep(1000);
threadB.interrupt(); // 成功中斷線程BReentrantLock.lockInterruptibly()底層機(jī)制：通過AQS的acquireInterruptibly()方法實(shí)現(xiàn)，內(nèi)部調(diào)用doAcquireInterruptibly()
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
// AQS的acquireInterruptibly方法
public final void acquireInterruptibly(int arg) throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (!tryAcquire(arg))
doAcquireInterruptibly(arg); // 支持中斷的等待
}不可中斷鎖(Non-Interruptible Lock)
一旦線程開始請求，就會一直阻塞等待，直到獲取鎖
java中的不可中斷鎖：synchronized和lock()
ReentrantLock lock = new ReentrantLock();
// 線程A獲取鎖并長期持有
new Thread(() -> {
lock.lock();
try {
Thread.sleep(10000); // 模擬長時間持有鎖
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
// 線程B嘗試獲取鎖（不可中斷）
Thread threadB = new Thread(() -> {
lock.lock(); // 不可中斷的鎖請求
try {
System.out.println("ThreadB獲取鎖成功");
} finally {
lock.unlock();
}
});
threadB.start();
// 主線程嘗試中斷線程B
Thread.sleep(1000);
threadB.interrupt(); // 無法中斷線程B的等待synchronized底層機(jī)制：JVM內(nèi)置鎖機(jī)制，等待鎖的線程進(jìn)入BLOCKED狀態(tài)，不響應(yīng)中斷
ReentrantLock.lock()底層機(jī)制：基于AQS框架，使用不可中斷模式加入等待隊列
使用場景：
- 不可中斷鎖適用場景
任務(wù)必須完成：如數(shù)據(jù)庫事務(wù)提交、關(guān)鍵數(shù)據(jù)寫入，不允許中途放棄。
簡單同步需求：使用synchronized快速實(shí)現(xiàn)線程安全。
- 可中斷鎖適用場景
- 高響應(yīng)性要求：如用戶取消操作、服務(wù)超時控制。
- 復(fù)雜任務(wù)管理：線程池任務(wù)調(diào)度、需要優(yōu)雅終止的后臺服務(wù)。
