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

运行展示：