Skip to content

2.4-2 synchronized 原理与锁升级 ​

所属:02 Java 运行时 / 2.4 并发 分级:A 状态:◐ 初稿 关联:2.4-1、2.4-3、2.4-4、2.4-5、2.4-9、2.4-10、2.4-11

  • 题型:原理

  • 一句话结论:synchronized 是 JVM 内置的互斥锁,字节码是 monitorenter/monitorexit(同步方法用 ACC_SYNCHRONIZED),底层依赖对象头 Mark Word 和 Monitor;无竞争时用偏向锁/轻量级锁减少内核调用,竞争激烈时膨胀为重量级锁挂起线程;它同时保证原子性、可见性和有序性,但锁升级、锁消除、锁粗化由 JVM/JIT 按运行时情况决定。

  • 分层要点:

    1. 使用形式与字节码:同步代码块编译成 monitorenter/monitorexit,编译器会生成正常退出和异常退出两条 monitorexit,保证异常时也能释放锁;同步方法用方法访问标志 ACC_SYNCHRONIZED,实例方法锁 this,静态方法锁 Class 对象。锁的是对象,不是代码块;同一个对象上的同步块互斥,不同对象互不影响。synchronized 是可重入的,Monitor 里用递归计数记录重入次数。
    2. 对象头与 Monitor:64 位 HotSpot 的 Mark Word 存 identity hash、GC age、biased_lock、lock 等标志;锁状态通常分为无锁(01)、偏向(101)、轻量级(00)、重量级(10),GC 标记(11)是另一条路径。偏向/轻量级状态下 Mark Word 存线程 ID 或指向栈上 Lock Record 的指针;膨胀后指向堆里的 ObjectMonitor。ObjectMonitor 的关键字段有 _owner、_recursions、_EntryList、_WaitSet、_cxq,分别表示持有者、重入次数、竞争队列和等待队列。
    3. 锁升级:偏向锁针对“同一个线程反复进入”的场景:第一次 CAS 把线程 ID 写进 Mark Word,后续同一线程进入不再做原子操作;一旦有其他线程竞争,需要在安全点撤销偏向。轻量级锁在线程栈帧里建 Lock Record,用 CAS 把 Mark Word 指向该记录;CAS 失败通常直接膨胀为重量级锁。重量级锁使用 ObjectMonitor,进入时先做自适应自旋,仍抢不到再 park 挂起,由 OS 调度唤醒,避免持续空转。升级通常不可逆;偏向锁撤销后回到无锁/轻量级,不是“降级”。JDK 15 起偏向锁默认禁用(JEP 374),后续版本移除,但面试仍要讲清这条历史路径。
    4. 内存语义与 wait/notify:monitorenter/monitorexit 带内存屏障语义,同一监视器的 unlock happens-before 后续 lock,所以临界区内的写对下一个进入临界区的线程可见;这同时提供了原子性、可见性和临界区内的有序性。wait() 必须持有监视器,调用后释放锁并进入 WaitSet;notify() 把等待者移到竞争队列,不是立刻执行;被唤醒后还要重新抢锁。等待必须放在 while 循环里检查条件,防止虚假唤醒和条件被其他线程改变;notifyAll() 通常比 notify() 安全。
    5. 性能与选型:无竞争时 synchronized 经过偏向/轻量级优化后成本很低,不要一概说“synchronized 慢”;竞争激烈时重量级锁有 park/unpark 和上下文切换成本。JIT 会做锁消除(逃逸分析发现锁对象不逃逸)和锁粗化(把相邻的多次加锁合并),减少开销。需要公平锁、tryLock、可中断、多个 Condition 时用 ReentrantLock;读多写少可考虑 StampedLock;纯计数用 LongAdder/原子类。JDK 21 虚拟线程中 synchronized 可能 pin 载体线程,后续版本才逐步解决,高并发虚拟线程场景优先 ReentrantLock。
  • 图/流程:

text
synchronized(obj)
  │
  ▼
Mark Word 锁状态
  ├─ 无锁 01
  ├─ 偏向 101:CAS 线程 ID;同线程后续无 CAS
  │      └─ 其他线程竞争 → 安全点撤销
  ├─ 轻量级 00:Lock Record + CAS
  │      └─ CAS 失败/竞争加剧 → 膨胀
  └─ 重量级 10:ObjectMonitor
         ├─ 自适应自旋 → park
         ├─ _owner / _recursions
         ├─ _EntryList / _cxq:竞争队列
         └─ _WaitSet:wait() 等待队列
  • 版本/源码锚点:

    • JLS 17.4:synchronized 的 happens-before 与内存语义。
    • HotSpot:objectMonitor.hpp、markWord.hpp、synchronizer.cpp。
    • JDK 6:偏向锁、轻量级锁、锁消除、锁粗化等优化引入。
    • JDK 15:JEP 374 默认禁用偏向锁;后续版本移除。
    • JDK 21:虚拟线程下 synchronized 可能 pin 载体线程,选型时注意。
  • 锁状态对比表:

状态触发场景实现代价
无锁未同步/刚分配Mark Word 01无
偏向锁同一线程反复进入CAS 线程 ID,后续无 CAS撤销需安全点;已默认禁用
轻量级锁少量竞争、短临界区Lock Record + CASCAS 失败即膨胀
重量级锁激烈竞争/CAS 失败ObjectMonitor + 自适应自旋 + park/unpark上下文切换、OS 调度
  • synchronized vs ReentrantLock:
维度synchronizedReentrantLock
实现层JVM 内置,字节码/MonitorJDK 层,AQS
释放自动释放,异常也释放必须 finally unlock
公平性非公平可选公平/非公平
可中断不支持lockInterruptibly
尝试加锁不支持tryLock
条件队列一个 wait/notify 集合多个 Condition
可重入支持支持
性能无竞争很轻,竞争重竞争下更灵活,可调
  • 追问链:

    1. synchronized 锁的到底是什么? → 锁的是对象关联的 Monitor;实例方法锁 this,静态方法锁 Class 对象,代码块锁括号里的对象。锁对象不同,互斥范围就不同。
    2. synchronized 的字节码是什么? → 同步块是 monitorenter/monitorexit,异常路径也有 monitorexit;同步方法是 ACC_SYNCHRONIZED 标志,JVM 在方法调用/返回时隐式加解锁。
    3. Mark Word 里有什么? → identity hash、GC 年龄、biased_lock、锁标志;偏向状态存线程 ID,轻量级存 Lock Record 指针,重量级存 ObjectMonitor 指针。具体位布局随 32/64 位和是否压缩指针变化。
    4. 锁升级的过程? → 无锁 → 偏向锁(单线程)→ 轻量级锁(少量竞争,CAS + 自旋)→ 重量级锁(竞争激烈,ObjectMonitor + park)。升级通常不可逆。
    5. 偏向锁为什么被废弃? → 撤销偏向需要安全点,代价高;现代 CAS 成本下降,偏向锁收益变小;JDK 15 默认禁用,后续移除。面试仍要能讲清它的设计。
    6. 轻量级锁怎么实现? → 每个线程在栈上建 Lock Record,CAS 把 Mark Word 指向它;成功即持有。CAS 失败通常膨胀为重量级锁;自旋发生在重量级锁的进入路径(自适应自旋),不是轻量级锁本身。
    7. 重量级锁为什么慢? → 竞争线程先自适应自旋,仍抢不到就 park 挂起,涉及用户态/内核态切换和 OS 调度;唤醒也有延迟。但竞争激烈时,挂起比持续自旋更省 CPU。
    8. synchronized 能保证可见性吗? → 能;unlock happens-before 后续 lock,monitorenter/monitorexit 还有内存屏障语义,临界区内的写对下一个进入临界区的线程可见。
    9. wait/notify 为什么必须放在循环里? → 防止虚假唤醒,也防止被唤醒后条件又被其他线程改变;标准写法是 while (!condition) wait();,而不是 if。
    10. wait/notify 和 sleep 有什么区别? → wait 释放监视器并进入 WaitSet,必须在 synchronized 内调用;sleep 不释放锁,只是让当前线程休眠。notify 不会立即切换执行,只是把等待者移到竞争队列。
    11. synchronized 和 ReentrantLock 怎么选? → 简单互斥优先 synchronized,代码短、自动释放;需要公平、tryLock、可中断、多个 Condition 时用 ReentrantLock;读多写少看 StampedLock。
    12. 什么是锁消除和锁粗化? → 锁消除是 JIT 通过逃逸分析发现锁对象不逃逸,直接去掉同步;锁粗化是把相邻的多次加锁合并成一次,减少反复加解锁。它们是 JIT 优化,不是语言语义。
    13. synchronized 是公平锁吗?能中断吗? → 不是公平锁,不保证先到先得;等待锁的线程不能被中断(wait 可以被中断),需要可中断就用 ReentrantLock。
    14. 虚拟线程下 synchronized 有什么问题? → JDK 21 中 synchronized 可能 pin 住载体线程,阻塞时无法卸载虚拟线程;高并发虚拟线程场景优先 ReentrantLock,后续 JDK 版本在改进。
  • 生产案例/取舍(示例,替换成你的项目):

    • DCL 单例用 synchronized 保证只创建一次,但实例字段仍需 volatile 防止发布重排;synchronized 解决互斥,volatile 解决可见性和有序性,两者不能互相替代。
    • 用 String 常量或 Integer 缓存对象做锁,导致不同业务无意间共享同一把锁,出现莫名阻塞;锁对象应是私有 final 的专用对象。
    • 热点接口在单例对象上做大范围同步,QPS 上来后线程全部排队;缩小临界区、按 key 分段锁或改用并发容器后恢复。
    • wait() 写在 if 里,被虚假唤醒后继续执行错误逻辑;改成 while 并配合 notifyAll。
    • 虚拟线程压测时吞吐上不去,jstack/JFR 发现大量载体线程被 pin;把 synchronized 换成 ReentrantLock 后恢复。
    • 取舍:synchronized 代码简单、自动释放,适合大多数互斥;ReentrantLock 灵活但有忘记 unlock 的风险;锁粒度越小并发越高,但锁太多会增加复杂度和死锁风险。
  • 易错点:

    • 认为 synchronized 锁的是代码块,而不是对象。
    • 认为锁升级在任何情况下都会发生,或认为可以随意降级。
    • 认为偏向锁现在仍然默认开启(JDK 15 起默认禁用)。
    • 认为 synchronized 一定比 ReentrantLock 慢;无竞争时它很轻。
    • 认为 wait() 不释放锁,或认为 notify() 后等待线程立刻执行。
    • 把 wait() 写在 if 里,忽略虚假唤醒。
    • 认为 synchronized 公平、可中断。
    • 用 String/Integer 常量做锁对象。
    • 在虚拟线程里大量使用 synchronized 造成 pinning,却只调线程池参数。
  • 30 秒口述稿:

synchronized 是 JVM 内置锁,同步块用 monitorenter/monitorexit,同步方法用 ACC_SYNCHRONIZED,底层是对象头 Mark Word 和 Monitor。无竞争时偏向锁让同一线程后续进入不做 CAS;轻量级锁用 Lock Record + CAS;CAS 失败膨胀成重量级锁,ObjectMonitor 先自适应自旋,再 park 挂起。它可重入,unlock happens-before 后续 lock,所以同时保证原子性、可见性和有序性。wait 会释放锁并进入 WaitSet,必须在 while 循环里等待。简单互斥优先 synchronized,需要公平、tryLock、可中断再用 ReentrantLock。

  • 3 分钟展开顺序:结论(JVM 内置锁 + 三种状态)→ 字节码与锁对象 → Mark Word/ObjectMonitor → 偏向锁 → 轻量级锁 → 重量级锁 → 内存语义与 wait/notify → 锁消除/粗化 → synchronized vs ReentrantLock → 虚拟线程 pinning 与生产案例。