← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L01 - synchronized锁升级全流程

本节目标(学完能回答的面试题)

核心知识(1小时精讲内容)

一、为什么需要锁升级

JDK 6之前,synchronized只有重量级锁(依赖操作系统的Mutex Lock),每次加锁/解锁都需要用户态→内核态切换,开销巨大。

JDK 6引入"锁升级"机制:根据竞争程度逐步升级锁,无竞争时几乎零开销。


锁升级方向(只升级不降级,GC时可批量重置):

  无锁 → 偏向锁 → 轻量级锁 → 重量级锁
   │        │          │           │
   │        │          │           └─ 竞争激烈,多线程长时间持有
   │        │          └─ 有轻度竞争,短时间交替持有
   │        └─ 无竞争,单线程重入
   └─ 刚创建的对象

二、Mark Word 64位结构(重点)

每个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标记

三、偏向锁(Biased Locking)

核心思想:如果一个锁始终只被同一个线程获取,就把锁"偏向"给这个线程,后续该线程加锁/解锁无需任何同步操作。

偏向锁获取流程:


线程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中偏向锁的维护成本常高于收益。

四、轻量级锁(Lightweight Lock)

核心思想:多个线程交替(非同时)获取锁时,通过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后自适应,不再固定)

五、重量级锁(Heavyweight Lock)

核心思想:依赖操作系统的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 vs ReentrantLock 对比(必背)

特性synchronizedReentrantLock
实现层面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,且代码更简洁不易出错。

面试速记卡(考前30秒速看)

练习题(自测)

1. 画出synchronized从无锁到重量级锁的完整升级流程,标注每个阶段的触发条件。

2. 解释为什么对象头中的hashcode和偏向锁线程ID不能共存(提示:31位hashcode vs 54位thread ID)。

3. 编写代码验证偏向锁:创建100个线程交替获取同一把锁,观察锁升级过程(提示:使用JOL工具打印对象头)。

4. 场景题:高并发计数器场景,synchronized和ReentrantLock哪个更合适?为什么?

5. 解释轻量级锁的"自适应自旋"机制,为什么比固定自旋更优?

学习资料