跳到主要内容
约 7 分钟2 张卡

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?​

9. 面试题卡片​

先想答案,再翻面先在心里答一遍,再点开卡片对照参考回答。卡片之间可以左右切换,看完会回到这里。
逐张翻看 2 张 →
未标记的卡读完后明天进入复习;已标记的按状态安排

10. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明