← 返回首页 📚 实战课程
📑 本篇章节导航 (共4章,点击直达)
一、理论篇(30%)—— 从对象头到 Monitor 的完整链路二、动手篇(40%)—— 用JOL亲眼看到锁状态变化三、面试模拟篇(20%)—— 追问链式考核四、练习篇(10%)

P1-01 - synchronized锁升级与Monitor机制

定位:你已经知道 synchronized 是锁,知道有锁升级,但面试官问"Mark Word 每一位的含义""偏向锁批量撤销的阈值""轻量级锁的 Lock Record 在哪"时,你答不上来。本节专治这个gap。

一、理论篇(30%)—— 从对象头到 Monitor 的完整链路

1.1 Mark Word 64位结构(逐字段背诵)

面试高频题:"请画出64位JVM下Mark Word的结构。"


64位 JVM Mark Word 布局(每行64 bits):

┌──────────────────────────────────────────────────────────────────┬──────────────┐
│                         Mark Word (64 bits)                       │    状态      │
├──────────────────────────────────────────────────────────────────┼──────────────┤
│ unused:25 | identity_hashcode:31 | unused:1 | age:4 | 0 | 01    │  无锁        │
├──────────────────────────────────────────────────────────────────┼──────────────┤
│ thread:54 |         epoch:2      | unused:1 | age:4 | 1 | 01    │  偏向锁      │
├──────────────────────────────────────────────────────────────────┼──────────────┤
│               ptr_to_lock_record:62                       | 00    │  轻量级锁    │
├──────────────────────────────────────────────────────────────────┼──────────────┤
│               ptr_to_heavyweight_monitor:62               | 10    │  重量级锁    │
├──────────────────────────────────────────────────────────────────┼──────────────┤
│                                                          | 11    │  GC标记      │
└──────────────────────────────────────────────────────────────────┴──────────────┘

最后3位:biased_lock(1bit) + lock(2bit)
  lock=01, biased_lock=0  →  无锁
  lock=01, biased_lock=1  →  偏向锁
  lock=00                 →  轻量级锁
  lock=10                 →  重量级锁
  lock=11                 →  GC标记

每个字段的含义(面试必问):

字段位数含义
identity_hashcode31bit延迟计算的hashCode,首次调用后才写入。一旦写入,不能偏向
thread54bit偏向锁持有线程ID(OS线程ID,非Java Thread引用)
epoch2bit偏向锁时间戳/批量重偏向的代龄
age4bitGC分代年龄(0-15,达到阈值晋升老年代)
ptr_to_lock_record62bit指向栈中Lock Record的指针(轻量级锁)
ptr_to_heavyweight_monitor62bit指向ObjectMonitor的指针(重量级锁)

关键细节(面试加分):

1.2 锁升级完整流程


对象刚创建
   │
   ▼
┌─────────┐    同一个线程再次进入synchronized     ┌─────────┐
│  无锁    │ ──────────────────────────────────→  │  偏向锁  │
│ (01,0)  │    (CAS将线程ID写入Mark Word)          │ (01,1)  │
└─────────┘                                       └─────────┘
                                                      │
                    另一个线程尝试获取                    │
                    (偏向锁撤销/重偏向)                  ▼
                                                 ┌──────────┐
                                                 │ 轻量级锁  │
                                                 │  (00)    │
                                                 └──────────┘
                                                      │
                    自旋失败(竞争激烈)                   │
                    或等待线程数 > 1                      ▼
                                                 ┌──────────┐
                                                 │ 重量级锁  │
                                                 │  (10)    │
                                                 └──────────┘

注意:锁只升级不降级(但GC时可批量重置偏向状态)

偏向锁批量重偏向与批量撤销(面试高频):

JVM维护了每个类对应的偏向锁计数器:

相关JVM参数:


-XX:BiasedLockingBulkRebiasThreshold=20    # 批量重偏向阈值
-XX:BiasedLockingBulkRevokeThreshold=40    # 批量撤销阈值
-XX:BiasedLockingStartupDelay=4000         # 偏向锁启动延迟(ms),JDK15后默认禁用
-XX:-UseBiasedLocking                       # 禁用偏向锁

1.3 轻量级锁的CAS流程


线程栈                              对象Mark Word
┌─────────────────┐                ┌──────────────────┐
│ Lock Record      │                │   无锁状态         │
│ ┌──────────────┐ │    CAS尝试     │   hashcode|age|01 │
│ │ Displaced    │ │ ←──────────── │                    │
│ │ Mark Word    │ │                └──────────────────┘
│ │ (保存原始MW) │ │
│ ├──────────────┤ │
│ │ 指向对象的引用│ │
│ └──────────────┘ │
└─────────────────┘

步骤:
1. 在当前栈帧中创建Lock Record
2. 将对象Mark Word拷贝到Lock Record的Displaced Mark Word中
3. CAS尝试将对象Mark Word更新为指向Lock Record的指针
4. 成功 → 获得轻量级锁,lock标志位变为00
5. 失败 → 自旋重试 / 升级重量级锁

1.4 Monitor机制(ObjectMonitor)

重量级锁对应 ObjectMonitor(C++ 实现,位于 ObjectMonitor.hpp):


ObjectMonitor 核心字段:
┌─────────────────────────────────────────┐
│  _owner    → 持有锁的线程                 │
│  _EntryList → 阻塞等待获取锁的线程队列     │
│  _WaitSet   → 调用wait()等待的线程队列     │
│  _count     → 重入计数                    │
│  _recursions → 重入次数                   │
└─────────────────────────────────────────┘

工作流程:
1. 线程进入 _EntryList 排队(BLOCKED状态)
2. 获取到锁 → _owner 指向该线程
3. 调用 obj.wait() → 释放锁,进入 _WaitSet(WAITING状态)
4. 被notify()唤醒 → 从 _WaitSet 移到 _EntryList,重新竞争锁
5. 释放锁 → _owner = null,唤醒 _EntryList 中的线程

1.5 synchronized vs ReentrantLock

维度synchronizedReentrantLock
实现JVM内置(monitorenter/monitorexit)AQS(Java层)
锁升级有(偏向→轻量→重量)无(直接AQS队列)
可中断不可lockInterruptibly()
超时不可tryLock(timeout)
公平性非公平可选公平/非公平
Condition只一个waitSet多个Condition队列
锁绑定只能锁对象可绑定多个条件

二、动手篇(40%)—— 用JOL亲眼看到锁状态变化

2.1 JOL 环境搭建


<!-- pom.xml -->
<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.17</version>
</dependency>

2.2 完整JOL实验:观察四种锁状态


import org.openjdk.jol.info.ClassLayout;
import org.openjdk.jol.vm.VM;

public class LockUpgradeDemo {

    // JVM参数:-XX:-UseBiasedLocking 可禁用偏向锁,方便观察
    // 注意:JDK 15+ 默认禁用偏向锁,需要 -XX:+UseBiasedLocking 开启

    static final class MyLock {
        // 空对象,只用于观察Mark Word
    }

    public static void main(String[] args) throws Exception {
        MyLock obj = new MyLock();

        // ========== 1. 无锁状态 ==========
        System.out.println("===== 1. 无锁状态 =====");
        // 调用hashCode会占用Mark Word的31位,阻止偏向锁
        System.out.println("hash = " + obj.hashCode());
        printMarkWord(obj, "无锁(已计算hashCode)");

        // ========== 2. 偏向锁状态 ==========
        // 需要JDK 14以下,或开启 -XX:+UseBiasedLocking
        // 且不调用hashCode
        MyLock biased = new MyLock();
        System.out.println("\n===== 2. 偏向锁 =====");
        synchronized (biased) {
            printMarkWord(biased, "偏向锁(同一线程)");
        }
        printMarkWord(biased, "偏向锁释放后(仍保留线程ID)");

        // ========== 3. 轻量级锁状态 ==========
        System.out.println("\n===== 3. 轻量级锁 =====");
        MyLock light = new MyLock();
        light.hashCode(); // 阻止偏向锁

        Thread t1 = new Thread(() -> {
            synchronized (light) {
                printMarkWord(light, "轻量级锁(线程A持有)");
            }
        }, "Thread-A");
        t1.start();
        t1.join();

        // ========== 4. 重量级锁状态 ==========
        System.out.println("\n===== 4. 重量级锁 =====");
        MyLock heavy = new MyLock();
        heavy.hashCode();

        // 两个线程竞争,升级为重量级锁
        CountDownLatch latch = new CountDownLatch(2);

        Thread t2 = new Thread(() -> {
            synchronized (heavy) {
                printMarkWord(heavy, "重量级锁(线程B持有)");
                latch.countDown();
                try { Thread.sleep(2000); } catch (Exception e) {}
            }
        }, "Thread-B");

        Thread t3 = new Thread(() -> {
            // 先让t2拿到锁
            try { Thread.sleep(500); } catch (Exception e) {}
            synchronized (heavy) {
                printMarkWord(heavy, "重量级锁(线程C等待后获取)");
                latch.countDown();
            }
        }, "Thread-C");

        t2.start();
        t3.start();
        latch.await();
        printMarkWord(heavy, "重量级锁释放后");
    }

    static void printMarkWord(Object obj, String stage) {
        System.out.println("【" + stage + "】");
        // 打印对象布局(Mark Word部分)
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        // 提取最后3位:biased_lock + lock
        // JVM返回的字符串中 Mark Word 行包含了实际值
        System.out.println();
    }
}

2.3 验证偏向锁批量撤销


import java.util.concurrent.TimeUnit;
import java.util.ArrayList;
import java.util.List;

/**
 * 验证偏向锁批量重偏向(阈值20)和批量撤销(阈值40)
 *
 * JVM参数:
 * -XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0
 * -XX:BiasedLockingBulkRebiasThreshold=20
 * -XX:BiasedLockingBulkRevokeThreshold=40
 */
public class BiasedLockBulkDemo {

    static final class MyObject {}

    public static void main(String[] args) throws Exception {
        // 等待偏向锁启动
        TimeUnit.SECONDS.sleep(6);

        List<MyObject> list = new ArrayList<>();

        // 阶段1:主线程创建并偏向50个对象
        for (int i = 0; i < 50; i++) {
            MyObject obj = new MyObject();
            synchronized (obj) {
                list.add(obj); // 主线程获得偏向锁
            }
        }

        // 阶段2:新线程逐个撤销偏向锁
        Thread t = new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                MyObject obj = list.get(i);
                synchronized (obj) {
                    // 前20个:逐个撤销偏向锁
                    // 第21个开始:触发批量重偏向,epoch+1
                    // 第40个开始:触发批量撤销
                    if (i == 19 || i == 20 || i == 39 || i == 40) {
                        System.out.println("第 " + (i+1) + " 个对象: " +
                            ClassLayout.parseInstance(obj).toPrintable());
                    }
                }
            }
        });
        t.start();
        t.join();
    }
}

2.4 Monitor等待队列实验


/**
 * 验证 Monitor 的 EntryList 和 WaitSet
 * 使用jstack观察线程状态
 */
public class MonitorQueueDemo {

    static final Object lock = new Object();

    public static void main(String[] args) throws Exception {
        // 线程1:持有锁并wait
        Thread waiter = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("waiter 进入 WAITING");
                    lock.wait(); // 进入 WaitSet
                } catch (InterruptedException e) {}
                System.out.println("waiter 被唤醒");
            }
        }, "Waiter-Thread");

        // 线程2、3:阻塞等待锁
        Thread blocker1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("blocker1 获得锁");
            }
        }, "Blocker1-Thread");

        Thread blocker2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("blocker2 获得锁");
            }
        }, "Blocker2-Thread");

        waiter.start();
        Thread.sleep(100);
        blocker1.start();
        blocker2.start();
        Thread.sleep(100);

        // 此时执行 jstack <pid> 观察:
        // waiter   → WAITING (on object monitor) — 在WaitSet中
        // blocker1 → BLOCKED (on object monitor) — 在EntryList中
        // blocker2 → BLOCKED (on object monitor) — 在EntryList中
        System.out.println("现在执行 jstack " + ProcessHandle.current().pid());
        Thread.sleep(30000); // 等待手动jstack

        synchronized (lock) {
            lock.notifyAll(); // 唤醒waiter
        }
    }
}

三、面试模拟篇(20%)—— 追问链式考核

Q1: synchronized的锁升级过程是怎样的?

追问链:


Q1.1: 为什么JDK 6要引入锁升级?之前是什么样的?
→ JDK 6之前只有重量级锁,依赖OS Mutex,每次加解锁都要用户态→内核态切换
→ 实际上大部分场景没有竞争,重量级锁是浪费

Q1.2: 偏向锁有什么问题?为什么JDK 15默认禁用?
→ 偏向锁撤销需要等到安全点(safepoint),代价高
→ 现代应用中多线程交替使用很常见,偏向锁收益不如撤销开销
→ JDK 15+ 默认 -XX:-UseBiasedLocking,将来会废弃

Q1.3: 轻量级锁什么情况下会升级为重量级锁?
→ 自旋超过阈值(自适应自旋,JVM根据上次自旋是否成功来动态调整)
→ 或者等待的线程数超过1个
→ 注意:不是"两个线程竞争就立刻升级"

Q1.4: 锁升级后能降级吗?
→ 不能。一旦升级到重量级锁,不会自动降级
→ 但在全局安全点(GC)时,JVM可以批量重置偏向锁状态

Q2: 请详细描述Mark Word的结构

追问链:


Q2.1: 为什么调用过hashCode的对象不能进入偏向锁?
→ 31位hashCode和54位thread ID共享Mark Word空间
→ 一旦hashCode被写入,空间不够存thread ID
→ 所以"已计算hashCode的对象"只能从无锁或轻量级锁开始

Q2.2: age字段只有4位,意味着什么?
→ GC分代年龄最大15
→ 超过MaxTenuringThreshold(默认6或15)晋升老年代
→ CMS下默认6,G1/Parallel下默认15

Q2.3: 轻量级锁的Lock Record在什么地方?
→ 在线程栈帧中(stack frame)
→ 每次进入synchronized块,都会在栈帧中分配一个Lock Record
→ Lock Record中包含 Displaced Mark Word(原始Mark Word的拷贝)
→ 解锁时用CAS将Displaced Mark Word写回对象头

Q3: synchronized和ReentrantLock的区别?

追问链:


Q3.1: 性能上哪个更好?
→ JDK 6之后 synchronized 经过锁升级优化,低竞争场景性能接近
→ 高竞争场景 ReentrantLock 更稳定(AQS队列式等待 vs 自旋消耗CPU)
→ 实际选型不应只看性能,更要看功能需求

Q3.2: 什么场景必须用ReentrantLock?
→ 需要可中断的锁获取:lockInterruptibly()
→ 需要超时获取:tryLock(timeout, unit)
→ 需要公平锁:new ReentrantLock(true)
→ 需要多个条件队列:多个Condition
→ 需要尝试非阻塞获取:tryLock()

Q3.3: synchronized是可重入的吗?怎么实现的?
→ 是可重入的
→ 偏向锁/轻量级锁:判断Mark Word中的thread ID是否是当前线程
→ 重量级锁:ObjectMonitor._recursions计数器递增

常见踩坑(5年经验仍会犯的错)

1. 以为偏向锁在两个线程竞争时就撤销 —— 错,偏向锁只在另一个线程尝试获取时撤销,但会先尝试重偏向

2. 以为锁可以降级 —— 错,只升不降(GC时可批量重置不算降级)

3. 以为轻量级锁就是自旋锁 —— 不完全对,轻量级锁是CAS+自适应自旋

4. 以为synchronized就是悲观锁 —— 锁升级的前两级(偏向、轻量)都是乐观策略

5. 在循环体内加synchronized —— 每次进出monitor都有开销,应该把synchronized加在循环外


四、练习篇(10%)

练习1:用JOL验证锁状态转换

编写程序,使用JOL打印同一个对象在以下状态下的Mark Word:

要求:提交Mark Word截图,标注每条线的含义。

练习2:模拟偏向锁批量撤销

编写程序,创建100个同一类型的对象,先让主线程获得偏向锁,然后用新线程逐个获取。

练习3:jstack验证Monitor队列

编写程序,创建1个wait线程(调用wait())和3个blocked线程(等待锁)。

练习4:synchronized vs ReentrantLock性能对比

编写JMH基准测试,对比以下场景:

分别测试synchronized和ReentrantLock的吞吐量,分析结果。