深入理解 synchronized：到底锁的是谁？

在 Java 多线程并发编程里，synchronized是保证线程安全的核心关键字，但很多开发者只知道它能加锁，却不清楚它到底锁的是什么、不同写法锁的范围有何区别。

这篇文章就把 synchronized 的锁对象、作用范围、经典测试用例一次性讲透，代码与测试结果完全还原，帮你彻底搞懂 synchronized 的 “锁事”。

一、synchronized 锁的核心结论

synchronized 本质锁的是对象，而非代码！不同写法对应不同锁对象：

1. 修饰实例方法→ 锁当前实例对象（this）
2. 修饰静态方法→ 锁当前类的 Class 对象
3. 修饰代码块→ 锁括号内指定的对象

只有锁的是同一个对象，多线程才会互斥等待；锁不同对象，互不影响。

二、完整测试用例（一模一样还原）

测试用例 1：synchronized 修饰实例方法（锁 this）

代码

public class SyncInstanceMethod { // 同步实例方法：锁当前对象 this public synchronized void test() { System.out.println(Thread.currentThread().getName() + " 进入同步方法"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 退出同步方法"); } public static void main(String[] args) { // 同一个对象 SyncInstanceMethod instance = new SyncInstanceMethod(); new Thread(() -> instance.test(), "线程A").start(); new Thread(() -> instance.test(), "线程B").start(); } }

执行结果

线程A 进入同步方法 线程A 退出同步方法 线程B 进入同步方法 线程B 退出同步方法

结论

同一个实例对象的同步方法，多线程互斥执行，锁是当前实例 this。

测试用例 2：不同实例调用实例同步方法（互不锁）

代码

public class SyncInstanceMethodDiff { public synchronized void test() { System.out.println(Thread.currentThread().getName() + " 进入同步方法"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 退出同步方法"); } public static void main(String[] args) { // 两个不同实例 SyncInstanceMethodDiff instance1 = new SyncInstanceMethodDiff(); SyncInstanceMethodDiff instance2 = new SyncInstanceMethodDiff(); new Thread(() -> instance1.test(), "线程A").start(); new Thread(() -> instance2.test(), "线程B").start(); } }

执行结果

线程A 进入同步方法 线程B 进入同步方法 线程A 退出同步方法 线程B 退出同步方法

结论

不同实例的同步方法，锁对象不同，不互斥，并发执行。

测试用例 3：synchronized 修饰静态方法（锁 Class 对象）

代码

public class SyncStaticMethod { // 同步静态方法：锁当前类 Class 对象 public static synchronized void test() { System.out.println(Thread.currentThread().getName() + " 进入静态同步方法"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 退出静态同步方法"); } public static void main(String[] args) { new Thread(() -> SyncStaticMethod.test(), "线程A").start(); new Thread(() -> SyncStaticMethod.test(), "线程B").start(); } }

执行结果

线程A 进入静态同步方法 线程A 退出静态同步方法 线程B 进入静态同步方法 线程B 退出静态同步方法

结论

静态同步方法锁的是类的 Class 对象，全局唯一，所有线程互斥。

测试用例 4：synchronized 修饰代码块（指定锁对象）

代码

public class SyncBlock { // 自定义锁对象 private final Object lock = new Object(); public void test() { // 同步代码块：锁 lock 对象 synchronized (lock) { System.out.println(Thread.currentThread().getName() + " 进入同步代码块"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 退出同步代码块"); } } public static void main(String[] args) { SyncBlock instance = new SyncBlock(); new Thread(() -> instance.test(), "线程A").start(); new Thread(() -> instance.test(), "线程B").start(); } }

执行结果

线程A 进入同步代码块 线程A 退出同步代码块 线程B 进入同步代码块 线程B 退出同步代码块

结论

同步代码块锁指定对象，粒度更灵活，是企业开发推荐写法。

测试用例 5：实例锁 VS 类锁（互不干扰）

代码

public class SyncInstanceAndClass { // 实例方法锁：this public synchronized void instanceMethod() { System.out.println(Thread.currentThread().getName() + " 进入实例方法"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 退出实例方法"); } // 静态方法锁：Class public static synchronized void staticMethod() { System.out.println(Thread.currentThread().getName() + " 进入静态方法"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 退出静态方法"); } public static void main(String[] args) { SyncInstanceAndClass instance = new SyncInstanceAndClass(); new Thread(() -> instance.instanceMethod(), "线程A").start(); new Thread(() -> SyncInstanceAndClass.staticMethod(), "线程B").start(); } }

执行结果

线程A 进入实例方法 线程B 进入静态方法 线程A 退出实例方法 线程B 退出静态方法

结论

实例锁（this）和类锁（Class）是两把完全独立的锁，互不阻塞。

三、一张表总结 synchronized 锁对象

四、核心要点回顾

1. synchronized 永远锁对象，不锁代码。
2. 只有锁同一个对象，才会互斥。
3. 实例锁和类锁是两把独立锁，互不影响。
4. 代码块锁粒度最细，性能最优，优先使用。

搞懂 synchronized 到底锁谁，是写出高并发、线程安全代码的第一步！