🔐 锁升级过程：从"佛系"到"暴躁"的蜕变！

面试考点：偏向锁、轻量级锁、重量级锁的升级过程和Mark Word变化

锁的一生，就像人的成长：

佛系青年 🧘 → 轻度焦虑 😰 → 暴躁老哥 😡
   ↓            ↓            ↓
 偏向锁      轻量级锁      重量级锁

今天咱们就来看看锁的**"成长史"**！🎓

🎯 为什么需要锁升级？

背景：传统重量级锁的痛点 💔

Java 1.5之前：synchronized只有重量级锁

每次加锁：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 用户态 → 内核态切换  ⏰ 慢！
2. 操作系统互斥量      ⏰ 慢！
3. 内核态 → 用户态切换  ⏰ 慢！
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

即使：
- 没有竞争
- 只有一个线程访问
- 也要走这个流程！😭
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Java 6的革命：锁优化 🎉

核心思想：大部分情况下，锁是没有竞争的！

统计数据：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
95%的锁：只有一个线程访问  🧘
4%的锁：有竞争，但很轻微    😰
1%的锁：激烈竞争            😡
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

优化策略：
根据竞争程度，动态升级锁！
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🏗️ 锁的四种状态

无锁 → 偏向锁 → 轻量级锁 → 重量级锁
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
特点：
✅ 只能升级，不能降级（JDK 15后可降级）
✅ 升级是自动的，无需手动
✅ 状态记录在对象头（Mark Word）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

生活类比 🏠

无锁：
自己家，不用锁门 🏡

偏向锁：
只有你住，门上贴个名字，直接进 🚪

轻量级锁：
偶尔有客人，敲门等一下 🔔

重量级锁：
很多人抢房间，找保安管理 👮

📦 对象头与Mark Word

对象内存布局 🏗️

Java对象 = 对象头 + 实例数据 + 对齐填充
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
┌─────────────────────────────────┐
│        对象头 (Header)           │
│  ┌─────────────────────────┐    │
│  │ Mark Word (8字节)        │ ← 关键！
│  ├─────────────────────────┤    │
│  │ Class Pointer (4/8字节)  │    │
│  └─────────────────────────┘    │
├─────────────────────────────────┤
│   实例数据 (Instance Data)       │
├─────────────────────────────────┤
│   对齐填充 (Padding)             │
└─────────────────────────────────┘
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Mark Word的秘密 🎭

Mark Word：64位（在64位JVM中），存储对象的运行时信息

64位 Mark Word 的多副面孔：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
根据锁状态，Mark Word存储不同内容！

┌────────────────────────────────────────┐
│  无锁状态                              │
├────────────────────────────────────────┤
│ unused(25) | hashcode(31) | age(4) | 0 | 01 |
│                                      ↑    ↑  │
│                                   偏向  锁标志│
└────────────────────────────────────────┘

┌────────────────────────────────────────┐
│  偏向锁状态                            │
├────────────────────────────────────────┤
│ threadID(54) | epoch(2) | age(4) | 1 | 01 |
│    ↑                               ↑    ↑  │
│ 线程ID                           偏向  锁标志│
└────────────────────────────────────────┘

┌────────────────────────────────────────┐
│  轻量级锁状态                          │
├────────────────────────────────────────┤
│ ptr_to_lock_record(62) | 00 |
│    ↑                      ↑  │
│ 栈中锁记录指针          锁标志│
└────────────────────────────────────────┘

┌────────────────────────────────────────┐
│  重量级锁状态                          │
├────────────────────────────────────────┤
│ ptr_to_monitor(62) | 10 |
│    ↑                  ↑  │
│ Monitor对象指针     锁标志│
└────────────────────────────────────────┘
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

锁标志位对照表：

锁状态	偏向标志	锁标志	存储内容
无锁	0	01	hashcode、age
偏向锁	1	01	线程ID、epoch、age
轻量级锁	-	00	栈中锁记录指针
重量级锁	-	10	Monitor指针
GC标记	-	11	（GC使用）

🧘 偏向锁（Biased Locking）

设计思想 💡

观察：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
大部分锁在整个生命周期内：
- 只被一个线程访问
- 从不发生竞争

优化：
既然总是同一个线程：
- 第一次记录线程ID
- 以后直接进，不用加锁！
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

加锁流程 🔑

线程A首次访问：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 检查Mark Word的锁标志
2. 发现是无锁状态（01）
3. CAS将线程ID写入Mark Word
4. 成功！偏向锁获取成功 ✅

线程A再次访问：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 检查Mark Word
2. 发现线程ID是自己
3. 直接进入同步块！⚡ 超快！
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

线程B来访问：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 检查Mark Word
2. 发现线程ID不是自己
3. 升级到轻量级锁！⬆️
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

代码示例 💻

public class BiasedLockDemo {
    private Object lock = new Object();
    
    public void method() {
        synchronized (lock) {
            // 第一次：CAS设置线程ID
            // 第二次：检查ID，直接进
            // 第三次：检查ID，直接进
            // ...
        }
    }
    
    public static void main(String[] args) {
        BiasedLockDemo demo = new BiasedLockDemo();
        
        // 同一个线程反复调用
        for (int i = 0; i < 1000; i++) {
            demo.method();  // 只有第一次CAS，后续都是直接进！⚡
        }
    }
}

偏向锁撤销 ❌

什么时候撤销？

1. 其他线程尝试获取锁
2. 调用hashCode()
3. 调用wait/notify
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

撤销过程：
1. 到达安全点（Safepoint）
2. 暂停拥有锁的线程
3. 检查线程是否还在同步块中
   - 是：升级为轻量级锁
   - 否：恢复为无锁状态
4. 恢复线程
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

批量重偏向和批量撤销 📦

场景：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
List<Object> list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
    list.add(new Object());
}

// 线程A：给所有对象加偏向锁
for (Object obj : list) {
    synchronized (obj) { /* ... */ }
}

// 线程B：访问相同对象
for (Object obj : list) {
    synchronized (obj) { /* ... */ }  
    // 触发批量重偏向！
}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

批量重偏向：
- 撤销次数达到20次
- JVM认为对象被不同线程轮流使用
- 批量将偏向撤销，重新偏向新线程

批量撤销：
- 撤销次数达到40次
- JVM认为该类不适合偏向锁
- 整个类的对象都不再使用偏向锁
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

关闭偏向锁 🔧

# JDK 6-14：默认开启
-XX:+UseBiasedLocking

# JDK 15+：默认关闭（因为收益不大）
-XX:-UseBiasedLocking

# 延迟开启（默认延迟4秒）
-XX:BiasedLockingStartupDelay=0

😰 轻量级锁（Lightweight Locking）

设计思想 💡

观察：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
有多个线程访问锁：
- 但不是同时访问
- 竞争不激烈
- 通过自旋等待即可

优化：
使用CAS + 自旋：
- 不需要操作系统介入
- 在用户态完成
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

加锁流程 🔑

线程A加锁：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 在栈帧中创建Lock Record（锁记录）
┌─────────────────────────────┐
│  Lock Record                │
│  ┌─────────────────────┐    │
│  │ Displaced Mark Word │ ← 备份原Mark Word
│  ├─────────────────────┤    │
│  │ Owner Pointer       │ ← 指向锁对象
│  └─────────────────────┘    │
└─────────────────────────────┘

2. 复制Mark Word到Displaced Mark Word

3. CAS将对象的Mark Word替换为Lock Record指针
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   Mark Word: [Lock Record指针 | 00]
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━

4. CAS成功 → 加锁成功 ✅
   CAS失败 → 自旋重试或升级
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

线程A解锁：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. CAS将Displaced Mark Word替换回对象
2. 成功 → 解锁成功 ✅
3. 失败 → 锁已升级，释放重量级锁
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

自旋优化 🔄

自旋 = 循环等待
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
while (获取锁失败) {
    // 空转，消耗CPU
    // 期望锁很快被释放
}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

自适应自旋：
- 上次自旋成功 → 增加自旋次数
- 上次自旋失败 → 减少自旋次数
- JVM自动调整，无需手动
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

生活类比：

自旋 = 等红绿灯 🚦
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
红灯倒计时3秒：
- 你在原地等（自旋）
- 不熄火，不离开

红灯倒计时60秒：
- 你熄火，玩手机（阻塞）
- 到点再启动（唤醒）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

轻量级锁升级 ⬆️

触发条件：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 自旋次数超过阈值（默认10次）
2. 自旋线程数超过CPU核心数一半
3. 其他线程也在等待锁
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

升级过程：
1. 分配Monitor对象
2. 将Mark Word指向Monitor
3. 锁标志位改为10（重量级锁）
4. 阻塞等待线程
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

😡 重量级锁（Heavyweight Locking）

Monitor对象 🎛️

Monitor = 操作系统互斥量 + 条件变量
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
┌─────────────────────────────┐
│  Monitor                    │
│  ┌─────────────────────┐    │
│  │ _owner: 拥有者线程  │    │
│  ├─────────────────────┤    │
│  │ _count: 重入次数    │    │
│  ├─────────────────────┤    │
│  │ _WaitSet: 等待队列  │ ← wait()的线程
│  ├─────────────────────┤    │
│  │ _EntryList: 锁池    │ ← 竞争的线程
│  └─────────────────────┘    │
└─────────────────────────────┘
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

加锁流程 🔑

线程A加锁：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 检查_owner
2. 如果为空：
   - 设置_owner = 线程A
   - 加锁成功 ✅
3. 如果不为空：
   - 进入_EntryList等待
   - 操作系统挂起线程（阻塞）⏸️
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

线程A解锁：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 设置_owner = null
2. 唤醒_EntryList中的一个线程
3. 被唤醒的线程竞争锁
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

wait/notify原理 📢

wait()：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 释放锁（_owner = null）
2. 进入_WaitSet等待
3. 阻塞 ⏸️
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

notify()：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 从_WaitSet中唤醒一个线程
2. 被唤醒的线程进入_EntryList
3. 竞争锁
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

notifyAll()：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
唤醒_WaitSet中的所有线程
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🎬 完整的锁升级过程

示例代码 💻

public class LockUpgradeDemo {
    private Object lock = new Object();
    
    public void doWork() {
        synchronized (lock) {
            // 业务逻辑
        }
    }
    
    public static void main(String[] args) throws Exception {
        LockUpgradeDemo demo = new LockUpgradeDemo();
        
        // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        // 阶段1: 无锁 → 偏向锁
        // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        Thread.sleep(5000);  // 等待偏向锁启动
        
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                demo.doWork();  // 第一次：CAS设置线程ID（偏向锁）
                                // 后续：检查ID，直接进
            }
        });
        t1.start();
        t1.join();
        
        System.out.println("阶段1完成：偏向锁");
        
        // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        // 阶段2: 偏向锁 → 轻量级锁
        // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                demo.doWork();  // 检测到其他线程，升级为轻量级锁
            }
        });
        t2.start();
        t2.join();
        
        System.out.println("阶段2完成：轻量级锁");
        
        // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        // 阶段3: 轻量级锁 → 重量级锁
        // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        Thread t3 = new Thread(() -> {
            synchronized (demo.lock) {
                try {
                    Thread.sleep(1000);  // 持有锁1秒
                } catch (InterruptedException e) {}
            }
        });
        
        Thread t4 = new Thread(() -> {
            synchronized (demo.lock) {
                // t4自旋等待，超过阈值后升级为重量级锁
            }
        });
        
        t3.start();
        Thread.sleep(100);  // 确保t3先获取锁
        t4.start();
        
        t3.join();
        t4.join();
        
        System.out.println("阶段3完成：重量级锁");
    }
}

升级时序图 📊

时间 ━━━━━━━━━━━━━━━━━━━━━━━━━━━→

线程1: ───┬─────────────┬───────────
         │ 偏向锁      │ 轻量级锁
         └─────────────┘

线程2:           ───┬──────────┬───
                   │ 轻量级锁 │
                   └──────────┘

线程3:                    ───┬───────
                            │ 重量级锁
                            │ (持有)
                            └───────

线程4:                    ───⏸️──────
                            等待
                            (阻塞)

Mark Word变化：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[hashcode | age | 0 | 01]  无锁
      ↓
[threadID | epoch | age | 1 | 01]  偏向锁
      ↓
[Lock Record指针 | 00]  轻量级锁
      ↓
[Monitor指针 | 10]  重量级锁
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 锁对比表

锁类型	优点	缺点	适用场景
偏向锁	无需CAS，极快	撤销开销大	单线程访问
轻量级锁	竞争不激烈时性能好	自旋消耗CPU	少量线程、持锁时间短
重量级锁	不消耗CPU	线程阻塞，上下文切换	激烈竞争、持锁时间长

性能对比 ⚡

场景：100万次加解锁
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
偏向锁：
- 单线程：50ms  ✅ 超快！
- 多线程：升级开销...

轻量级锁：
- 无竞争：80ms  ✅ 很快
- 轻度竞争：150ms  ⚠️ 还行
- 激烈竞争：升级到重量级...

重量级锁：
- 激烈竞争：500ms  ⚠️ 慢
- 但不会更慢了（底线）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🎯 锁优化技巧

1. 减小锁粒度 🔬

// ❌ 粗粒度锁
public synchronized void method() {
    doA();  // 10ms
    doB();  // 100ms
    doC();  // 10ms
}

// ✅ 细粒度锁
public void method() {
    synchronized (lockA) { doA(); }
    doB();  // 不需要锁
    synchronized (lockC) { doC(); }
}

2. 锁分离 🔀

// ❌ 读写共用一个锁
public synchronized Object get(String key) { ... }
public synchronized void put(String key, Object value) { ... }

// ✅ 读写锁分离
private ReadWriteLock lock = new ReentrantReadWriteLock();

public Object get(String key) {
    lock.readLock().lock();
    try {
        return map.get(key);
    } finally {
        lock.readLock().unlock();
    }
}

public void put(String key, Object value) {
    lock.writeLock().lock();
    try {
        map.put(key, value);
    } finally {
        lock.writeLock().unlock();
    }
}

3. 锁粗化 🎯

// ❌ 频繁加锁解锁
for (int i = 0; i < 1000; i++) {
    synchronized (lock) {
        list.add(i);
    }
}

// ✅ 锁粗化
synchronized (lock) {
    for (int i = 0; i < 1000; i++) {
        list.add(i);
    }
}

4. 锁消除 ✂️

// JIT会自动消除不必要的锁
public void method() {
    StringBuffer sb = new StringBuffer();  // 局部变量
    sb.append("a");  // StringBuffer内部是synchronized的
    sb.append("b");
    // JIT发现sb不会逃逸，自动消除锁！
}

💡 Pro Tips

Tip 1: 查看锁状态 🔍

使用JOL（Java Object Layout）工具：

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.16</version>
</dependency>

import org.openjdk.jol.info.ClassLayout;

public class LockStateViewer {
    public static void main(String[] args) throws Exception {
        Object obj = new Object();
        
        // 1. 无锁状态
        System.out.println("无锁:");
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        
        // 2. 偏向锁
        Thread.sleep(5000);  // 等待偏向锁启动
        synchronized (obj) {
            System.out.println("偏向锁:");
            System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        }
        
        // 3. 轻量级锁
        new Thread(() -> {
            synchronized (obj) {
                System.out.println("轻量级锁:");
                System.out.println(ClassLayout.parseInstance(obj).toPrintable());
            }
        }).start();
    }
}

Tip 2: 避免锁升级 🚫

# 对于高并发场景，直接关闭偏向锁
-XX:-UseBiasedLocking

# 原因：
# - 偏向锁撤销开销大
# - 高并发下很快升级，不如直接用轻量级锁

Tip 3: 监控锁竞争 📊

ThreadMXBean threadMBean = ManagementFactory.getThreadMXBean();

// 开启线程竞争监控
threadMBean.setThreadContentionMonitoringEnabled(true);

// 获取锁等待时间
long waitedTime = threadMBean.getThreadInfo(threadId).getWaitedTime();
long blockedTime = threadMBean.getThreadInfo(threadId).getBlockedTime();

System.out.println("等待时间: " + waitedTime + "ms");
System.out.println("阻塞时间: " + blockedTime + "ms");

🎓 面试要点

高频问题

Q1: synchronized是怎么实现的？

答案： 基于Monitor对象：

1. 偏向锁：Mark Word记录线程ID，CAS设置
2. 轻量级锁：栈中Lock Record，CAS + 自旋
3. 重量级锁：Monitor对象，操作系统互斥量

Q2: 为什么有锁升级？

答案：

• 大部分锁没有竞争（95%）
• 锁升级可以根据竞争程度优化性能
• 无竞争用偏向锁（最快）
• 轻度竞争用轻量级锁（较快）
• 激烈竞争用重量级锁（保底）

Q3: 锁能降级吗？

答案：

• JDK 15之前：不能降级
• JDK 15+：引入了ZGC，支持锁降级
• 但降级条件苛刻，实际很少发生

🎉 总结

🎯 锁升级路径

无锁 → 偏向锁 → 轻量级锁 → 重量级锁
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
触发条件：
1. 单线程 → 偏向锁
2. 其他线程 → 轻量级锁
3. 自旋失败 → 重量级锁
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📋 优化建议

1. 减少锁范围：只锁必要代码
2. 减少锁时间：尽快释放
3. 锁分离：读写锁、分段锁
4. 无锁编程：CAS、ThreadLocal

---

记住：锁升级是JVM的自动优化，理解原理才能写出高性能代码！⚡

🌟 "锁的艺术在于：该快则快，该慢不慌！" 😎