JUC并發編程（二）Monitor/自旋/輕量級/鎖膨脹/wait/notify/鎖消除

一基礎

1 概念

2?賣票問題

3 轉賬問題

二鎖機制與優化策略

?0?Monitor?

1 輕量級鎖

2 鎖膨脹

3 自旋

4 偏向鎖

5 鎖消除

6 wait /notify

7 sleep與wait的對比

8 join原理

一基礎

1 概念

臨界區

一段代碼塊內如果存在對共享資源的多線程讀寫操作，撐這段代碼區為臨界區。

競態條件

多個線程在臨界區內執行，由于代碼的執行序列不同而導致結果無法預測，稱之為發生了競態條件

為了避免臨界區的競態條件發生，有多種手段可以達到目的

阻塞式的解決方案：synchronized,Lock
非阻塞式的解決方案：原子變量

2?賣票問題

代碼實現：

首先代碼實現了一個窗口類實現對賣票的相關業務邏輯，其次在主方法當中定義多個線程實現對票的購買，實現了sell方法的安全，random隨機數的安全，集合的安全，同時利用.join方法等待所有線程執行結束。

package day01.mysafe;import java.util.ArrayList;
import java.util.List;import java.util.Vector;
import java.util.concurrent.ThreadLocalRandom;public class example1 {static int randomAmount() {return ThreadLocalRandom.current().nextInt(1, 6);}public static void main(String[] args) throws InterruptedException {//模擬賣票List<Integer> arr = new Vector<>();List<Thread> threads = new ArrayList<>();TicketWindow ticketWindow = new TicketWindow(1000);for (int i = 0; i < 2200; i++) {Thread t = new Thread(() -> {int num = ticketWindow.sell(randomAmount());arr.add(num);});threads.add(t);t.start();}//等待所有線程執行完for (Thread thread : threads) {thread.join();}System.out.println("剩余：" + ticketWindow.getAmount());System.out.println("賣出：" + arr.stream().mapToInt(x -> x == null ? 0 : x).sum());}
}/*** 窗口類*/
class TicketWindow {private int amount;public TicketWindow(int number) {this.amount = number;}public int getAmount() {return amount;}/*** 賣票*/public synchronized int sell(int amount) {if (this.amount >= amount) {this.amount -= amount;return amount;} else {return 0;}}
}

3 轉賬問題

加實例鎖

鎖的是當前對象，每個對象都有獨立的鎖，只影響一個實例的并發操作，多個實例可以并發進行。會出現死鎖問題，當線程1 獲取 a的鎖，將a鎖住需要修改b但是需要b的鎖，此時需要等待b的鎖，但是同時線程2獲取b的鎖，將b鎖住需要修改a但是需要a的鎖，兩個線程相互等待，持續僵持導致死鎖。

import java.util.concurrent.ThreadLocalRandom;public class example2 {static int random() {return ThreadLocalRandom.current().nextInt(1, 100);}public static void main(String[] args) throws InterruptedException {Amount a = new Amount(1000);Amount b = new Amount(1000);Thread t1 = new Thread(() -> {for (int i = 0; i < 100; i++) {a.transfer(b, random());}}, "t1");Thread t2 = new Thread(() -> {for (int i = 0; i < 100; i++) {b.transfer(a, random());}}, "t2");t1.start();t2.start();t1.join();t2.join();System.out.printf("余額為%d\n", b.getMoney() + a.getMoney());}}class Amount {private int money;public Amount(int money) {this.money = money;}public int getMoney() {return money;}public void setMoney(int money) {this.money = money;}//轉賬 （向a賬戶轉賬money元）public synchronized void transfer(Amount a, int money) {if (this.money >= money) {this.money -= money;a.money += money;}}}

加類鎖

import java.util.concurrent.ThreadLocalRandom;public class example2 {static int random() {return ThreadLocalRandom.current().nextInt(1, 100);}public static void main(String[] args) throws InterruptedException {Amount a = new Amount(1000);Amount b = new Amount(1000);Thread t1 = new Thread(() -> {for (int i = 0; i < 100; i++) {a.transfer(b, random());}},  "t1");Thread t2 = new Thread(() -> {for (int i = 0; i < 100; i++) {b.transfer(a, random());}},  "t2");t1.start();t2.start();t1.join();t2.join();System.out.printf("余額為%d\n", b.getMoney()+a.getMoney());}}class Amount {private int money;public Amount(int money) {this.money = money;}public int getMoney() {return money;}public void setMoney(int money) {this.money = money;}//轉賬 （向a賬戶轉賬money元）public void transfer(Amount a, int money) {synchronized (Amount.class){if (this.money >= money) {this.money -= money;a.money += money;}}}}

二鎖機制與優化策略

?0?Monitor?

Monitor被翻譯為監視器或管程。Monitor 是 JVM 實現?synchronized?的核心機制，通過 EntryList、WaitSet 和 Owner 管理線程對鎖的訪問。

當線程首次通過?synchronized?競爭 obj 的鎖時，JVM 會在底層為其關聯一個 Monitor，如果Owner沒有對應的線程，則會成功獲取線程鎖，否則進入EntryList阻塞排隊. (同一對象使用synchroized)

下面介紹線程持有鎖并執行 wait/sleep 的運作狀態（sleep可以在沒有鎖的狀態運行，無鎖就只釋放CPU，有鎖釋放CPU，但鎖不釋放）

鎖的爭搶（進入EntryList）→ 持有（成為Owner）→ <wait>? 主動讓出,將鎖釋放（進入WaitSet）→ <notify> 喚醒后重新競爭->(進入EntryList)。
鎖的爭搶（進入EntryList）-->持有Owner -> <sleep> 主動讓出CPU時間片，不釋放鎖，變為TIMED_WAITING狀態同時維持Owner身份->時間結束后自動恢復運行，無需重新進入EntryList競爭。

Monitor 由以下核心組件構成：

Owner（持有者）：當前持有鎖的線程。
EntryList（入口隊列）：等待獲取鎖的線程隊列。
WaitSet（等待隊列）：調用?wait()?方法后釋放鎖的線程隊列。

1 輕量級鎖

輕量級鎖：如果一個對象雖然有多線程訪問，但多線程訪問的時間是錯開的（也就沒有競爭），那么就可以使用輕量級鎖來優化。

輕量級鎖對使用者是透明的，語法依舊是synchroized，不需要人工干預。

?低競爭時用輕量級鎖：當多線程競爭較小時（如交替執行同步代碼），JVM 會優先使用輕量級鎖（基于 CAS 操作），避免直接使用重量級鎖（Monitor）的性能開銷。
?競爭加劇時升級：如果輕量級鎖的 CAS 操作失敗（其他線程同時競爭），JVM 會自動將其升級為重量級鎖（通過操作系統互斥量實現阻塞）。

2 鎖膨脹

鎖膨脹是 JVM 在并發壓力增大時，將輕量級鎖升級為重量級鎖的過程，以犧牲部分性能換取線程安全。

觸發條件：

輕量級鎖競爭失敗：當多個線程同時競爭輕量級鎖（CAS 操作失敗），JVM 會將鎖升級為重量級鎖。
調用?wait()/notify()：這些方法需要重量級鎖（Monitor）的支持，會強制觸發膨脹。
HashCode 沖突：若對象已計算哈希碼，無法再使用偏向鎖或輕量級鎖，直接膨脹。

3 自旋

概念：自旋是“不停嘗試”的鎖獲取策略

當首個線程獲取輕量級鎖后，第二個嘗試訪問的線程不會立即阻塞或促使鎖升級，而是先進入自旋狀態，等待原先的線程釋放鎖。若在自旋期間鎖被釋放，則該線程可直接獲得鎖，避免進入阻塞狀態及觸發鎖升級至重量級鎖，從而提高效率并減少資源消耗。這種機制有效降低了因鎖升級帶來的性能損耗，確保了在并發環境下的高效運行。

4 偏向鎖

偏向鎖是Java虛擬機（JVM）中一種針對同步操作的優化技術，主要用于減少無競爭情況下的同步開銷。它是JVM鎖升級機制的第一階段（無鎖→偏向鎖→輕量級鎖→重量級鎖）。

在JDK15及以后版本，由于現代硬件性能提升和其他優化技術的出現，偏向鎖默認被禁用，因為其帶來的收益已經不明顯，而撤銷開銷在某些場景下可能成為負擔。

偏向鎖與輕量級鎖之間的對比

偏向鎖	輕量級鎖
針對無競爭場景（同一線程多次獲取鎖）	針對低競爭場景（多個線程交替執行，無并發沖突）
消除整個同步過程的開銷	避免操作系統互斥量（Mutex）的開銷

偏向鎖的核心機制

首次獲取鎖：
通過一次?CAS操作?將線程ID寫入對象頭的Mark Word，之后該線程進入同步塊無需任何原子操作。
無競爭時：
執行同步代碼就像無鎖一樣（僅檢查線程ID是否匹配）。
遇到競爭：
觸發偏向鎖撤銷（需暫停線程），升級為輕量級鎖。

輕量級鎖的核心機制

加鎖過程：
1. 在棧幀中創建鎖記錄（Lock Record）
2. 用CAS將對象頭的Mark Word復制到鎖記錄中
3. 再用CAS將對象頭替換為指向鎖記錄的指針（成功則獲取鎖）
解鎖過程：
用CAS將Mark Word還原回對象頭（若失敗說明存在競爭，升級為重量級鎖）。

?關鍵差異：

偏向鎖：全程只需1次CAS（首次獲取時）

輕量級鎖：每次進出同步塊都需要CAS（加鎖/解鎖各1次）

5 鎖消除

鎖消除是JVM中一項重要的編譯器優化技術，它通過移除不必要的同步操作來提升程序性能。這項技術主要解決"無實際競爭情況下的無效同步"問題。

鎖消除基于逃逸分析（Escape Analysis）?技術：

JVM在運行時分析對象的作用域
判斷對象是否會"逃逸"出當前線程（即被其他線程訪問）
如果確認對象不會逃逸（線程私有），則消除該對象的所有同步操作

public String concatStrings(String s1, String s2) {// StringBuilder是方法內部的局部變量StringBuilder sb = new StringBuilder();sb.append(s1);  // 內部有synchronized塊sb.append(s2);  // 內部有synchronized塊return sb.toString();
}

StringBuilder實例sb是方法局部變量
逃逸分析確認sb不會逃逸出當前線程（不會被其他線程訪問）
JIT編譯器會消除所有synchronized同步操作

6 wait /notify

首先涉及三個組件，Owner，EntryList，WaitSet。

組件	存儲線程狀態	觸發條件	是否持有鎖	位置轉移方向
Owner	RUNNABLE	成功獲取鎖	是	→ WaitSet (wait()時)
EntryList	BLOCKED	競爭鎖失敗	否	← WaitSet (notify()后)
WaitSet	WAITING	主動調用wait()	否	→ EntryList (被喚醒后)

一個線程進入時首先會嘗試獲取Owner權，也就是獲取鎖，但是同一時刻只能有一個線程持有鎖，獲取成功可以直接執行臨界代碼區，獲取失敗的線程待在EntryList當中，處于Blocked阻塞狀態，在持有鎖階段可以使用wait方法，會使當前鎖釋放，并進入WaitSet當中，處于Waiting等待狀態，其必須使用notify/notifyAll喚醒才可進入EntryList當中，從而再次得到競爭Owner的權力。

代碼示意

代碼開啟兩個線程，對同一個對象實例加鎖，線程1進入鎖后，執行wait進入WaitSet進入阻塞等待，線程1將鎖釋放，此時線程2獲取到鎖，將線程1喚醒，線程1將后續代碼執行結束。

在線程2當中睡眠3s一定程度上確保其在線程1之后執行（一定程度上避免出現永久阻塞等待的狀態），線程1阻塞等待，線程2喚醒。
線程1被喚醒之后會將線程當中剩余的代碼執行結束，然后進入EntryList中。
wait可加參數，相當于設置一個超時時間，在這個期間中等待，超時自動釋放。
在類文件當中加入一個Boolean標志位可以防止虛假喚醒的出現，虛假喚醒指的是在沒有明確使用notify/notifyAll對線程進行喚醒的條件下而被喚醒或者喚醒的并不是想要的。（借助while循環持續判斷）

package day01.mysynchronized;public class Example4 {static final Object obj = new Object();static boolean isSignaled = false; // 新增標志位public static void main(String[] args) {System.out.println("線程1開始執行");Thread t1 = new Thread(() -> {try {synchronized (obj) {System.out.println("線程1處于等待狀態....");// 循環檢查標志位，防止虛假喚醒while (!isSignaled) {obj.wait();}System.out.println("線程1執行結束");}} catch (InterruptedException e) {Thread.currentThread().interrupt();}}, "t1");Thread t2 = new Thread(() -> {System.out.println("線程2開始執行,睡眠3秒...");try {Thread.sleep(3000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}synchronized (obj) {System.out.println("線程2對線程1進行喚醒");isSignaled = true; // 設置標志位為trueobj.notify();System.out.println("線程2執行結束，線程1被喚醒");}}, "t2");t2.start();t1.start();}
}

運行展示：