三种 synchronized 锁方式详解

1. 普通同步方法：锁是当前实例对象（this）

语法形式

public synchronized void method() { // 业务逻辑 }

本质等价写法

普通同步方法等价于在方法体内用synchronized(this)包裹代码，锁对象是调用该方法的当前实例对象：

public void method() { synchronized (this) { // 锁 = 当前实例对象 // 业务逻辑 } }

案例演示

public class Data { // 普通同步方法：锁 this public synchronized void fun1() { try { Thread.sleep(3000); // 模拟耗时操作，持有锁3秒 System.out.println("1111111"); } catch (InterruptedException e) { e.printStackTrace(); } } // 普通同步方法：锁 this（和 fun1 共享同一把锁） public synchronized void fun2() { System.out.println("2222222"); } } // 测试类 public class SyncTest1 { public static void main(String[] args) { Data data = new Data(); Thread t1 = new Thread(() -> data.fun1()); Thread t2 = new Thread(() -> data.fun2()); t1.start(); t2.start(); } }

执行结果：

（等待约3秒） 1111111 2222222

核心结论：

• 锁对象是this，只有同一个实例对象的同步方法才会互斥。
• 不同实例对象的同步方法互不影响（比如new Data().fun1()和new Data().fun2()不会阻塞）。
• 适合实例级别的线程安全场景，比如操作单个对象的共享资源。

2. 静态同步方法：锁是当前类的 Class 对象

语法形式

public static synchronized void staticMethod() { // 业务逻辑 }

本质等价写法

静态同步方法等价于在方法体内用synchronized(类名.class)包裹代码，锁对象是当前类的 Class 对象（全局唯一）：

public static void staticMethod() { synchronized (Data.class) { // 锁 = 当前类的 Class 对象 // 业务逻辑 } }

案例演示

public class Data { // 静态同步方法：锁 Data.class public static synchronized void staticFun1() { try { Thread.sleep(3000); System.out.println("1111111 (static)"); } catch (InterruptedException e) { e.printStackTrace(); } } // 静态同步方法：锁 Data.class（和 staticFun1 共享同一把锁） public static synchronized void staticFun2() { System.out.println("2222222 (static)"); } } // 测试类 public class SyncTest2 { public static void main(String[] args) { Thread t1 = new Thread(() -> Data.staticFun1()); Thread t2 = new Thread(() -> Data.staticFun2()); t1.start(); t2.start(); } }

执行结果：

（等待约3秒） 1111111 (static) 2222222 (static)

核心结论：

• 锁对象是类名.class，全局唯一，无论创建多少个实例，所有线程调用该类的静态同步方法都会竞争同一把锁。
• 适合类级别的全局线程安全场景，比如操作静态共享资源（如静态计数器、单例对象）。

3. 同步代码块：锁是 synchronized 括号内配置的对象

语法形式

synchronized (锁对象) { // 业务逻辑 }

同步代码块是最灵活的方式，可以自由指定锁对象，常见有三种写法：

写法 1：锁 this（和普通同步方法等价）

public void fun1() { synchronized (this) { // 锁当前实例 try { Thread.sleep(3000); System.out.println("1111111 (block this)"); } catch (InterruptedException e) { e.printStackTrace(); } } } public void fun2() { synchronized (this) { // 和 fun1 共享 this 锁 System.out.println("2222222 (block this)"); } }

效果：和普通同步方法完全一致，同一实例的方法互斥。

写法 2：锁 Class 对象（和静态同步方法等价）

public void fun1() { synchronized (Data.class) { // 锁类对象 try { Thread.sleep(3000); System.out.println("1111111 (block class)"); } catch (InterruptedException e) { e.printStackTrace(); } } } public void fun2() { synchronized (Data.class) { // 和 fun1 共享类锁 System.out.println("2222222 (block class)"); } }

效果：和静态同步方法完全一致，全局互斥。

写法 3：锁自定义对象（细粒度锁，推荐）

这是最推荐的写法，可以实现更细粒度的锁控制，避免不必要的互斥：

public class Data { // 自定义锁对象（private final 防止外部修改） private final Object lock1 = new Object(); private final Object lock2 = new Object(); public void fun1() { synchronized (lock1) { // 只锁 lock1 try { Thread.sleep(3000); System.out.println("1111111 (block lock1)"); } catch (InterruptedException e) { e.printStackTrace(); } } } public void fun2() { synchronized (lock2) { // 锁 lock2，和 lock1 互不干扰 System.out.println("2222222 (block lock2)"); } } } // 测试类 public class SyncTest3 { public static void main(String[] args) { Data data = new Data(); Thread t1 = new Thread(() -> data.fun1()); Thread t2 = new Thread(() -> data.fun2()); t1.start(); t2.start(); } }

执行结果：

2222222 (block lock2) （等待约3秒） 1111111 (block lock1)

核心结论：

• 锁对象可以是任意引用类型（推荐用private final Object自定义锁）。
• 可以只锁关键代码段，减少锁持有时间，提升并发性能。
• 适合复杂同步场景，比如需要对不同资源分别加锁的场景。

三、三种锁方式对比总结