JDK 6之前,synchronized只有重量级锁(依赖操作系统的Mutex Lock),每次加锁/解锁都需要用户态→内核态切换,开销巨大。
JDK 6引入"锁升级"机制:根据竞争程度逐步升级锁,无竞争时几乎零开销。
锁升级方向(只升级不降级,GC时可批量重置):
无锁 → 偏向锁 → 轻量级锁 → 重量级锁
│ │ │ │
│ │ │ └─ 竞争激烈,多线程长时间持有
│ │ └─ 有轻度竞争,短时间交替持有
│ └─ 无竞争,单线程重入
└─ 刚创建的对象
每个Java对象都有一个对象头(Object Header),其中Mark Word存储锁状态信息。
64位 JVM Mark Word 布局(64 bits):
|---------------------------------------------|--------------------|
| Mark Word (64 bits) | 状态 |
|---------------------------------------------|--------------------|
| unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 | 无锁(可偏向) |
|---------------------------------------------|--------------------|
| thread:54 | epoch:2 | unused:1 | age:4 | biased_lock:1 | lock:2 | 偏向锁 |
|---------------------------------------------|--------------------|
| ptr_to_lock_record:62 | lock:2 | 轻量级锁 |
|---------------------------------------------|--------------------|
| ptr_to_heavyweight_monitor:62 | lock:2 | 重量级锁 |
|---------------------------------------------|--------------------|
| | lock:2 | GC标记 |
|---------------------------------------------|--------------------|
最后2位(lock)含义:
01 - 无锁/偏向锁(由biased_lock位区分)
00 - 轻量级锁
10 - 重量级锁
11 - GC标记
核心思想:如果一个锁始终只被同一个线程获取,就把锁"偏向"给这个线程,后续该线程加锁/解锁无需任何同步操作。
偏向锁获取流程:
线程A首次获取锁:
1. 检查Mark Word的 biased_lock == 1 且 lock == 01(可偏向状态)
2. 检查thread ID是否等于当前线程ID
3. 若相等 → 直接获取锁(零开销)
4. 若不相等 → 通过CAS尝试将线程ID写入Mark Word
├─ CAS成功 → 获取偏向锁
└─ CAS失败 → 说明有竞争,触发偏向锁撤销
偏向锁撤销(Revoke):
偏向锁撤销流程:
1. 等待全局安全点(STW)
2. 检查持有偏向锁的线程是否存活
├─ 不活跃 → 重置为无锁状态(可偏向)
└─ 活跃 → 升级为轻量级锁
3. 恢复栈中的锁记录
4. 恢复对象头
注意:偏向锁撤销需要STW,代价很高!
批量重偏向与批量撤销:
JVM维护了偏向锁撤销计数器,每个class有独立计数:
批量重偏向(Bulk Rebias):
- 某class的撤销计数达到 阈值(默认20次)
- 触发批量重偏向:将该class所有实例的epoch+1
- 之后新线程获取时可直接CAS替换thread ID
批量撤销(Bulk Revoke):
- 某class的撤销计数达到 更高阈值(默认40次)
- 该class所有实例的偏向锁全部失效
- 后续新实例直接跳过偏向锁阶段
注意:JDK 15开始默认关闭偏向锁(-XX:-UseBiasedLocking),因为现代JVM中偏向锁的维护成本常高于收益。
核心思想:多个线程交替(非同时)获取锁时,通过CAS自旋避免线程阻塞。
轻量级锁加锁流程:
1. 在当前栈帧中创建 Lock Record(锁记录)
2. 将对象Mark Word拷贝到Lock Record中(Displaced Mark Word)
3. CAS尝试将对象Mark Word替换为指向Lock Record的指针
├─ CAS成功 → 获取轻量级锁,Mark Word的lock变为00
└─ CAS失败 → 自旋重试
├─ 自旋成功 → 获取锁
└─ 自旋超过阈值 → 膨胀为重量级锁
轻量级锁解锁流程:
1. CAS将Displaced Mark Word替换回对象Mark Word
├─ 成功 → 释放完成
└─ 失败 → 说明已膨胀为重量级锁,唤醒被阻塞的线程
自旋优化:
自适应自旋(Adaptive Spinning):
- JDK 6引入,JVM根据上一次自旋的成功率动态调整自旋次数
- 上次自旋成功 → 增加自旋次数
- 上次自旋失败 → 减少甚至跳过自旋,直接膨胀
- 默认自旋次数:-XX:PreBlockSpin=10(JDK 6后自适应,不再固定)
核心思想:依赖操作系统的Mutex(互斥锁),未获取锁的线程进入BLOCKED状态,由OS调度唤醒。
重量级锁流程:
ObjectMonitor(C++实现):
+------------------+
| _owner | ← 持有锁的线程
| _EntryList | ← 阻塞等待锁的线程队列
| _WaitSet | ← 调用wait()后等待的线程队列
| _count | ← 重入计数
| _recursions | ← 重入次数
+------------------+
线程获取锁失败:
→ 进入 _EntryList 阻塞(内核态)
→ 持有锁的线程释放锁时唤醒 _EntryList 中的线程
→ 涉及用户态↔内核态切换,开销大
┌───────────────────────────────────────────────────────────────┐
│ synchronized 锁升级全景 │
├───────────────────────────────────────────────────────────────┤
│ │
│ 新建对象 │
│ │ │
│ ▼ │
│ [无锁: biased_lock=1, lock=01] │
│ │ │
│ │ 线程A首次synchronized │
│ ▼ │
│ [偏向锁: Mark Word写入线程A的ID] │
│ │ │
│ │ 线程B尝试获取锁(CAS失败) │
│ │ → 等待STW → 撤销偏向锁 │
│ ▼ │
│ [轻量级锁: CAS自旋] │
│ │ │
│ │ 自旋失败(竞争激烈/持有时间长) │
│ ▼ │
│ [重量级锁: ObjectMonitor, 线程阻塞] │
│ │ │
│ │ 释放锁后不降级(除非GC重置) │
│ └──→ 保持重量级锁状态 │
│ │
└───────────────────────────────────────────────────────────────┘
| 特性 | synchronized | ReentrantLock |
|---|---|---|
| 实现层面 | JVM内置(monitorenter/monitorexit) | JDK API(AQS实现) |
| 锁获取方式 | 自动获取/释放 | 手动 lock()/unlock() |
| 可中断 | 不可中断 | lockInterruptibly() 可中断 |
| 公平性 | 非公平 | 可选公平/非公平 |
| 条件变量 | 只有一个wait/notify | 多个Condition |
| 可超时 | 不支持 | tryLock(timeout) |
| 锁绑定 | 不支持 | 绑定多个Condition |
| 自旋/锁升级 | 有(偏向→轻量→重量) | 无(直接CAS+AQS队列) |
| 异常安全 | 自动释放 | 必须finally中unlock |
| 适用场景 | 简单同步,竞争少 | 复杂同步,需高级特性 |
synchronized字节码层面:
// Java代码
synchronized (obj) {
// critical section
}
// 字节码
monitorenter // 获取锁(引用计数+1)
// critical section
monitorexit // 释放锁(引用计数-1)
// 异常处理中也有 monitorexit(保证异常时释放)
ReentrantLock基本用法:
ReentrantLock lock = new ReentrantLock();
try {
lock.lock();
// 临界区
} finally {
lock.unlock(); // 必须在finally中释放!
}
// 可中断获取锁
try {
lock.lockInterruptibly();
// 临界区
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock();
}
// 超时获取锁
if (lock.tryLock(3, TimeUnit.SECONDS)) {
try {
// 临界区
} finally {
lock.unlock();
}
} else {
// 获取锁超时的处理
}
Q1: synchronized是可重入锁吗?
是。每个对象关联一个Monitor,内部有计数器(_recursions),同一线程可重入,计数+1,退出时-1,减到0才释放。
Q2: 偏向锁为什么在JDK 15后被默认关闭?
现代应用中锁通常会被多个线程竞争,偏向锁的撤销需要STW,维护成本(偏向→轻量的撤销开销)常大于收益。
Q3: 锁能降级吗?
正常运行期间不会降级(只升级不降级)。但在GC的STW阶段,JVM会扫描所有对象,可以安全地重置部分锁状态。
Q4: 为什么synchronized不需要手动释放?
编译器在字节码层面保证:正常退出和异常退出都会生成monitorexit指令,由JVM自动释放。
Q5: 什么场景下synchronized比ReentrantLock更好?
简单同步场景下,JVM对synchronized做了大量优化(锁升级、逃逸分析、锁消除),性能不亚于ReentrantLock,且代码更简洁不易出错。
1. 画出synchronized从无锁到重量级锁的完整升级流程,标注每个阶段的触发条件。
2. 解释为什么对象头中的hashcode和偏向锁线程ID不能共存(提示:31位hashcode vs 54位thread ID)。
3. 编写代码验证偏向锁:创建100个线程交替获取同一把锁,观察锁升级过程(提示:使用JOL工具打印对象头)。
4. 场景题:高并发计数器场景,synchronized和ReentrantLock哪个更合适?为什么?
5. 解释轻量级锁的"自适应自旋"机制,为什么比固定自旋更优?