结论先行:JDK 6 之后 synchronized 不再是「一上来就找操作系统要锁」的重量级实现,而是按竞争激烈程度逐级膨胀:无锁 → 偏向锁 → 轻量级锁 → 重量级锁。多数场景下 synchronized 性能已不输 ReentrantLock,日常业务代码不必为了性能刻意换显式锁。
锁信息存在哪:对象头 Mark Word
锁状态记录在对象头的 Mark Word 里(64 位 JVM 上占 8 字节),不同状态下存放内容不同:无锁时是 hashCode + 分代年龄 + 锁标志位,偏向锁时换成持有线程 ID,轻量级锁时是指向栈上锁记录的指针,重量级锁时是指向 ObjectMonitor 的指针。锁升级基本是单向的,膨胀为重量级后不会自动退回——这个设计的前提是「一旦出现重量级竞争,大概率会持续」。四个级别的存储内容与触发条件集中对照:
| 级别 | Mark Word 内容 | 适用场景 | 升级触发条件 |
|---|---|---|---|
| 无锁 | hashCode + 分代年龄 + 标志位 | 对象未被锁定 | 首次加锁请求 |
| 偏向锁 | 持有线程 ID | 锁始终由同一线程获取 | 出现第二个竞争线程 |
| 轻量级锁 | 指向栈上 Lock Record 的指针 | 线程交替持有、临界区很短 | 自旋失败或竞争持续 |
| 重量级锁 | 指向 ObjectMonitor 的指针 | 竞争激烈、临界区较长 | 自旋超过阈值 |
理解 Mark Word 的复用还有个推论:对象处于无锁状态时 Mark Word 里要存 hashCode,而偏向锁状态下存不下它——所以一个对象调用过 identityHashCode 之后就再也无法进入偏向状态。这个冷知识可以解释部分「偏向锁怎么没生效」的疑惑。
偏向锁:只有一个线程的场景
当锁始终由同一个线程获取时,Mark Word 记下该线程 ID,之后该线程再进入只需比对 ID,连 CAS 都省了,代价几乎为零,适合「一把锁基本只被一个线程用」的场景。注意两点:一是出现并发竞争时偏向锁要撤销,撤销必须等到安全点,成本不低;二是高并发场景下频繁撤销反而拖慢程序,JDK 15 起(JEP 374)偏向锁默认禁用并标记废弃——新代码不需要再为它做优化。了解它的价值主要在维护存量 JDK 8 系统时:如果应用明确是多线程高竞争模型,早期调优手册里「开启/关闭偏向锁」的参数才有讨论意义;新版本上这条优化路径已经退役。
排查遗留系统时,如果 GC 日志里频繁出现偏向锁撤销相关的安全点停顿,可以用 -XX:-UseBiasedLocking 关掉它做对照验证——这在旧版本 JVM 上是真实有效的调优项,也再次说明偏向锁的收益场景比想象中窄:批量处理、并行计算这类「多线程抢同一批对象锁」的应用关掉偏向锁反而更快。
轻量级锁:线程交替持有
出现第二个线程竞争时膨胀为轻量级锁:加锁线程在栈帧里建一条 Lock Record,把 Mark Word 复制进去(这一步叫 Displaced Mark Word),再用 CAS 把对象头指向这条 Lock Record。第二个线程 CAS 失败后先自旋几圈,赌锁很快释放——适合锁持有时间短、线程交替进入的场景。自旋是有代价的:空转的线程占着 CPU 什么都干不了。所以自旋不是无限度的,超过限制就升级,而且 JDK 用的是自适应自旋:上次在同一把锁上自旋成功了,这次多转几圈;上次失败了,这次直接放弃,减少无谓空转。
概念上还要澄清一点:轻量级锁并不是「乐观锁」,也不等于自旋锁——加锁本体是 CAS 指向 Lock Record,自旋只是第二条线程 CAS 失败后的等待策略。混淆这几个概念,读源码时流程会对不上号。
重量级锁:交给操作系统
自旋超过限制或竞争持续,锁膨胀为重量级锁:依赖操作系统的互斥量(mutex),抢不到锁的线程被挂起、让出 CPU。代价是用户态与内核态的切换以及线程唤醒的调度开销,这也是早期 synchronized 被诟病「重」的根源;好处是被阻塞的线程不再空耗 CPU。ObjectMonitor 内部维护了竞争队列等结构,锁的等待与通知(对应 wait/notify)都由它支撑。jstack 里看到大量线程 BLOCKED(on monitor entry)并伴随 park 痕迹,基本就是锁已经走到重量级了。
除了锁升级,JIT 还带来两项针对 synchronized 本身的优化。逃逸分析带来两个优化:锁消除——对象不可能被其他线程访问时直接删掉 synchronized,典型例子是方法内局部 StringBuffer 的 append;锁粗化——连续多次对同一对象加锁解锁,合并为一次大范围加锁。所以「StringBuffer 一定比 StringBuilder 慢」在局部变量场景并不成立:
// 这段代码里的锁会被 JIT 消除:sb 不可能逃逸出方法
String join(List<String> parts) {
StringBuffer sb = new StringBuffer(); // 局部变量,无逃逸
for (String p : parts) {
sb.append(p); // 每次 append 都有 synchronized,但锁被消除,
} // 运行开销与 StringBuilder 几乎一致
return sb.toString();
}
实战:锁对象与锁粒度
业务代码首选 synchronized:写法简单、JVM 持续优化、不怕忘记解锁。需要 tryLock 超时、可中断获取、多条件队列(多个 Condition)时再换 ReentrantLock。锁对象建议用私有的 final 对象,不要锁 this、String 字面量或 Integer 缓存对象——它们可能被不相干的代码共享,等于把私有锁变成了公共锁:
// 错误写法:锁的是「公共可拿到的对象」,锁范围不可控
synchronized ("ORDER_LOCK") { /* 字符串常量池全局共享,
其他代码锁同一字面量就会互相阻塞 */ }
synchronized (this) { /* 外部代码也能拿到 this 并锁它 */ }
// 正确写法:私有 final 锁对象 + 按业务 key 细分粒度
public class OrderService {
private final Object lock = new Object();
private final Map<Long, Object> keyLocks = new ConcurrentHashMap<>();
public void updateGlobal(Order o) {
synchronized (lock) { /* 只保护真正的全局共享状态 */ }
}
public void updateOne(Long orderId) {
// 每个订单一把锁:不同订单互不阻塞,锁粒度从服务级降到订单级
Object keyLock = keyLocks.computeIfAbsent(orderId, k -> new Object());
synchronized (keyLock) { /* 只保护该订单的状态 */ }
}
}
注意 keyLocks 本身会随 key 增长,长期运行的服务要配过期清理,或用带弱引用值的缓存实现自动回收。私有锁的另一个好处是锁粒度可控:对热点数据按 key 细分锁对象(每个订单一把锁),比整个服务一把大锁的吞吐高得多。
最后是命名与注释习惯:锁对象本身不承载业务语义,但给它一个清晰的名字(如 orderLock)并在注释里写明「保护的是哪个字段」,能让后续维护者在改临界区前先想清楚范围——锁的注释是并发代码里性价比最高的文档。
生产案例
某次线上排查接口批量超时,jstack 显示大量业务线程 BLOCKED,锁对象不是业务对象而是一个字符串常量——两处毫不相干的代码都用了 synchronized ("SYNC_KEY") 这样的写法,一段是库存同步,一段是消息去重,彼此完全不知道对方的存在。高峰期两个逻辑在同一个全局锁上排队,各自把对方拖慢,表现为「两条业务线同时变慢、又都找不到自己的瓶颈」。整改把所有锁字符串字面量的位置替换为私有 final 锁对象,热点路径再按业务 key 细分锁。这个案例说明锁升级机制解释的是「一把锁内部怎么变重」,而线上更常见的问题是「本来不该共享的锁被共享了」——前者看源码就懂,后者只能靠 jstack 抓现场。