定位:你已经知道 synchronized 是锁,知道有锁升级,但面试官问"Mark Word 每一位的含义""偏向锁批量撤销的阈值""轻量级锁的 Lock Record 在哪"时,你答不上来。本节专治这个gap。
面试高频题:"请画出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_hashcode | 31bit | 延迟计算的hashCode,首次调用后才写入。一旦写入,不能偏向 |
| thread | 54bit | 偏向锁持有线程ID(OS线程ID,非Java Thread引用) |
| epoch | 2bit | 偏向锁时间戳/批量重偏向的代龄 |
| age | 4bit | GC分代年龄(0-15,达到阈值晋升老年代) |
| ptr_to_lock_record | 62bit | 指向栈中Lock Record的指针(轻量级锁) |
| ptr_to_heavyweight_monitor | 62bit | 指向ObjectMonitor的指针(重量级锁) |
关键细节(面试加分):
System.identityHashCode() 的对象无法进入偏向锁状态(因为没有空间同时存hashCode和thread ID)
对象刚创建
│
▼
┌─────────┐ 同一个线程再次进入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 # 禁用偏向锁
线程栈 对象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. 失败 → 自旋重试 / 升级重量级锁
重量级锁对应 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 中的线程
| 维度 | synchronized | ReentrantLock |
|---|---|---|
| 实现 | JVM内置(monitorenter/monitorexit) | AQS(Java层) |
| 锁升级 | 有(偏向→轻量→重量) | 无(直接AQS队列) |
| 可中断 | 不可 | lockInterruptibly() |
| 超时 | 不可 | tryLock(timeout) |
| 公平性 | 非公平 | 可选公平/非公平 |
| Condition | 只一个waitSet | 多个Condition队列 |
| 锁绑定 | 只能锁对象 | 可绑定多个条件 |
<!-- pom.xml -->
<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>0.17</version>
</dependency>
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();
}
}
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();
}
}
/**
* 验证 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
}
}
}
追问链:
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.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.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计数器递增
1. 以为偏向锁在两个线程竞争时就撤销 —— 错,偏向锁只在另一个线程尝试获取时撤销,但会先尝试重偏向
2. 以为锁可以降级 —— 错,只升不降(GC时可批量重置不算降级)
3. 以为轻量级锁就是自旋锁 —— 不完全对,轻量级锁是CAS+自适应自旋
4. 以为synchronized就是悲观锁 —— 锁升级的前两级(偏向、轻量)都是乐观策略
5. 在循环体内加synchronized —— 每次进出monitor都有开销,应该把synchronized加在循环外
编写程序,使用JOL打印同一个对象在以下状态下的Mark Word:
要求:提交Mark Word截图,标注每条线的含义。
编写程序,创建100个同一类型的对象,先让主线程获得偏向锁,然后用新线程逐个获取。
编写程序,创建1个wait线程(调用wait())和3个blocked线程(等待锁)。
编写JMH基准测试,对比以下场景:
分别测试synchronized和ReentrantLock的吞吐量,分析结果。