synchronized
synchronized 是 Java 内置的锁,它借助对象的监视器(monitor)协调线程:同一时刻只有一个线程能持有某个对象的 monitor,而且线程解锁前的写入,对随后拿到同一 monitor 的线程可见。每个 Java 对象都关联一个 monitor,所以任何对象都能当锁用。用对 synchronized 的关键是先认清锁的是哪个对象,因为只有锁同一个对象的代码之间才互斥;在此基础上,再理解 HotSpot 怎样降低加锁成本,以及 wait/notify 怎样在锁上实现等待。
1. 面试核心
先记住这几条,再读正文- 实例同步方法锁定
this,静态同步方法锁定声明类的Class对象,同步块锁定括号中指定的对象。 - 同一线程可以重复获取同一个 monitor,退出次数与进入次数相同后才完全释放锁。
- 线程解锁前的写入,对随后取得同一 monitor 的线程可见。卡 · 对象 monitor 与可重入
wait()会释放目标 monitor 并进入等待,返回前重新获取它并恢复原持有次数。卡 · monitor 的等待与通知- Java 17/21 的 HotSpot 默认不使用偏向锁,「偏向锁 → 轻量级锁 → 重量级锁」是旧版本实现的描述。
2. 对象 monitor 与可重入
判断几段代码能不能互斥,第一步是找出它们锁的是哪个对象。下面的同步块要求线程先取得 lock 对象的 monitor,才能修改 state:
public void update() {
synchronized (lock) {
state = next(state);
}
}
一个线程持有这个 monitor 时,其他线程要进入以 lock 为锁的同步区域,都得等它释放。持有者自己可以再次获取同一个 monitor,这叫可重入。monitor 记录持有次数,每进入一次加一,每退出一次减一,降到零时其他线程才能取得锁。可重入让同步方法可以放心调用同一对象上的另一个同步方法,否则线程会卡在等自己释放的锁上。
锁对象必须一致。下面两段代码能否互斥,取决于 left 和 right 是否指向同一个对象:
synchronized (left) { /* 修改 state */ }
synchronized (right) { /* 也修改 state */ }
如果 left 和 right 指向不同对象,两段代码用的是不同的 monitor,两个线程可以同时修改 state,加了锁也等于没加。所以需要互斥的访问路径,要共用同一个、不会被替换的锁对象。
3. 同步方法与同步代码块
synchronized 写在不同位置,锁的对象也不同,有三种写法:
- 实例同步方法锁定当前对象
this。 - 静态同步方法锁定声明这个方法的类的
Class对象。 - 同步块锁定括号里表达式求值得到的对象。
由此可以推出几种常见情况:同一个实例上的两个实例同步方法竞争同一个 monitor,不能同时执行;不同实例的同步方法各锁各的对象,可以并行;实例同步方法和静态同步方法锁的对象不同,彼此之间也不互斥。
在字节码层面,两者的实现方式不同。同步块编译成 monitorenter 和 monitorexit 指令,编译器还会为异常路径生成一份 monitorexit,保证抛出异常时也释放锁。同步方法不生成这两条指令,而是在 Class 文件里带上 ACC_SYNCHRONIZED 标志,JVM 调用方法时获取 monitor,方法正常返回或异常退出时释放。
4. 可见性保证
锁除了让线程轮流进入,还让后来的线程看到前面的修改。线程甲释放某个 monitor,线程乙随后取得同一个 monitor,乙就能看到甲解锁前的所有写入。这是 Java 内存模型规定的解锁与后续加锁之间的 happens-before 关系,具体推导见 Java 内存模型。
这条保证要求读写双方都加同一把锁。只在写入时加锁、读取时不加锁,读线程和写线程之间就没有这条关系,读线程可能一直看到旧值。
被锁保护的代码叫临界区。临界区要覆盖必须一起完成的读写,比如「检查余额、再扣款」要放在同一次加锁里,拆成两次加锁,中间就可能有别的线程插进来。临界区也要控制耗时:如果持锁期间调用远程服务,所有等这把锁的线程都要陪着等网络响应。
5. HotSpot 的锁优化
加锁本身有成本,HotSpot 会根据竞争情况选择不同的获取方式,尽量少让线程挂起和切换。可以按三类竞争情况理解:
- 没有竞争时,走快速获取路径,用很少的原子操作就完成加锁。
- 竞争时间很短时,线程可以自旋,也就是循环几次尝试获取锁,而不是立刻挂起。持有者很快释放的话,省掉了一次挂起和唤醒。
- 竞争持续、需要完整的等待管理时,锁膨胀为完整的 monitor,由它管理线程的阻塞和唤醒。
具体用哪种锁表示、走哪条获取路径,取决于 JDK 版本、虚拟机实现、启动参数和实际竞争。这些都是实现层面的优化,程序是否正确,只依赖 monitor 的互斥和可见性规则。
Java 17/21 的 HotSpot 默认不使用偏向锁。Java 8 时代资料里的「偏向锁 → 轻量级锁 → 重量级锁」描述的是当时的实现,不是每次加锁都要经过的流程;对象头各个位的含义等细节,也要放在具体版本里讨论。
Java 21 中,虚拟线程持有 monitor 时阻塞,会固定住它底下的载体线程,这叫 pinning,具体影响见 虚拟线程。
6. 锁消除与锁粗化
除了让单次加锁更便宜,JIT 编译器还能减少实际执行的加锁次数。JIT 把运行中的热点代码编译成本地机器码时,会分析哪些同步操作可以省掉或合并:
- 锁消除:编译器证明锁对象只有当前线程能访问时,去掉对它的加锁和解锁。其他线程根本接触不到这个对象,不加锁行为也不会变。
- 锁粗化:编译器把相邻的、反复获取同一把锁的几段代码合并成一次加锁,减少反复进入和退出的成本。
能不能优化取决于编译器的分析结果和实际执行路径,所以源码仍然要按正确的同步范围来写。指望编译器优化而随手加同步,或者手动扩大临界区把慢 I/O 也包进去,都只会增加不必要的工作和等待。
要确认优化是否发生,可以看 JIT 编译日志;要找出竞争和等待发生在哪里,可以结合 JFR(JVM 自带的运行事件记录工具)和基准测试。
7. monitor 的等待与通知
线程拿到锁后,有时会发现业务条件还不满足,比如消费者发现队列是空的。这时它需要释放锁去等待,让生产者有机会拿锁放入数据。对象的 wait、notify 和 notifyAll 就是做这件事的,调用它们时必须持有这个对象的 monitor,否则抛出 IllegalMonitorStateException。
条件检查也要放在同一把锁内。消费者等待队列非空可以这样写:
synchronized (lock) {
while (queue.isEmpty()) {
lock.wait();
}
return queue.removeFirst();
}
这段代码所在的方法需要处理或声明 InterruptedException。队列为空时,wait() 把线程放进 lock 的等待集合(记录正在等通知的线程),并完全释放 lock,即使之前重入了多次也一并释放。被唤醒后,线程先重新获取 monitor、恢复原来的持有次数,再回到 while 检查队列。
生产者要在同一把锁内先更新队列,再发通知。notify() 从等待集合里选一个线程唤醒,notifyAll() 唤醒全部。通知之后,生产者仍持有 monitor,直到退出同步区域,所以被唤醒的线程还要等它释放,再重新竞争锁。
这里用 while 而不是 if,原因有两个:线程可能在没有收到通知的情况下从 wait() 返回,这叫虚假唤醒;即使收到了通知,别的消费者也可能在它拿到锁之前把数据取走。所以醒来后要再确认队列非空,才删除元素。
还有两点要注意。wait 只释放目标 monitor,线程持有的其他锁不会释放;如果生产者需要这些锁才能放入数据,双方就会互相等待。另外,通知不会保存下来留给以后的等待者:没有线程在等时调用 notify(),这次通知就丢了。所以必须先持锁检查状态,条件不满足才进入等待,而不是不检查就直接 wait()。
8. 常见问题
8.1 等待进入 monitor 时可以中断或设置超时吗?
不可以。线程阻塞在 synchronized 入口等锁时,interrupt() 只会设置中断状态,线程仍然继续等锁;synchronized 也没有超时参数。这和已经持锁后调用 wait() 不同,wait() 会响应中断并抛出 InterruptedException。需要可中断获取、超时获取或多个条件队列时,用 ReentrantLock。
8.2 为什么锁对象引用常声明为 final?
为了防止锁字段在运行中被换成另一个对象。字段被重新赋值后,换值之前进入的线程锁的是旧对象,之后进入的线程锁的是新对象,两者不再互斥。声明为 final 能保证各条访问路径一直用同一个 monitor。final 只保证引用不变,互斥规则仍由 synchronized 提供。
9. 面试题卡片
10. 参考资料
- JLS 17.1:Synchronization
- JVMS 3.14:Compiling Synchronization
- Java 17:偏向锁选项
- JLS 17.2:Wait Sets and Notification
- HotSpot:Performance Enhancements
- OpenJDK 21:C2 LockNode 锁粗化实现
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明