java 中区分对象锁和类锁的核心在于 synchronized 修饰的目标是实例方法还是静态方法,以及 lock 关键字后跟随的是当前实例还是 class 对象。对象锁保护的是特定实例的状态,同一时刻只有一个线程能访问该实例的同步代码;类锁保护的是类的静态资源或所有实例共享的逻辑,同一时刻只有一个线程能访问类的同步代码块。理解这一区别的关键是明确锁对象的身份:this 代表当前对象实例,而 classname.class 代表类的 class 元数据对象。

实例方法中的对象锁机制
当 synchronized 直接修饰非静态方法时,它自动获取当前实例(this)作为锁对象。这意味着每个对象实例都有自己独立的锁,不同实例之间的调用互不干扰。例如,如果两个线程分别操作同一个类的两个不同实例,它们可以同时进入各自的 synchronized 方法而不发生阻塞。这种机制适用于需要隔离实例状态的场景,确保单个对象内部数据的一致性。

public class ObjectLockExample {
public synchronized void instanceMethod() {
System.out.println("Thread: " + Thread.currentThread().getName() + " acquired object lock");
try { Thread.sleep(1000); } catch (InterruptedException e) {}
System.out.println("Thread: " + Thread.currentThread().getName() + " released object lock");
}
public static void main(String[] args) {
ObjectLockExample obj1 = new ObjectLockExample();
ObjectLockExample obj2 = new ObjectLockExample();
Thread t1 = new Thread(() -> obj1.instanceMethod(), "T1");
Thread t2 = new Thread(() -> obj2.instanceMethod(), "T2");
t1.start();
t2.start();
}
}
运行上述代码,T1 和 T2 会几乎同时打印“acquired object lock”,因为 obj1 和 obj2 是不同的实例,拥有不同的锁。这验证了对象锁的独立性。预期结果是两个线程并行执行,总耗时约 1 秒而非 2 秒。若将 obj2 改为 obj1,则 T2 必须等待 T1 释放锁后才能进入,此时才会串行执行。
立即学习“Java免费学习笔记(深入)”;
使用Atmosphere构建通过WebSocket、SSE、gRPC、WebTransport、MCP、A2A和AG-UI流传输的JVM代理网关,并带有治理钩子。
静态方法中的类锁机制
当 synchronized 修饰静态方法时,它获取的是该类对应的 Class 对象作为锁。类锁与实例无关,无论创建多少个实例,所有线程在访问该类的任何静态同步方法时都必须竞争同一把锁。这确保了静态资源或类级别逻辑的线程安全。例如,单例模式的初始化或全局计数器的更新通常使用类锁来防止并发冲突。

public class ClassLockExample {
private static int counter = 0;
public static synchronized void staticMethod() {
System.out.println("Thread: " + Thread.currentThread().getName() + " acquired class lock");
counter++;
try { Thread.sleep(1000); } catch (InterruptedException e) {}
System.out.println("Thread: " + Thread.currentThread().getName() + " released class lock, counter: " + counter);
}
public static void main(String[] args) {
Thread t1 = new Thread(() -> staticMethod(), "T1");
Thread t2 = new Thread(() -> staticMethod(), "T2");
t1.start();
t2.start();
}
}
运行上述代码,T1 和 T2 会串行执行,因为 staticMethod 使用类锁。T1 进入后,T2 必须等待 T1 退出才能进入。预期结果是总耗时约 2 秒,counter 最终为 2。注意,即使有多个实例,静态方法的类锁依然唯一。若一个线程持有对象锁,另一个线程持有类锁,它们不会互相阻塞,因为锁对象不同。
基于 lock(this) 和 lock(Class.class) 的具体问题
在代码中显式使用 synchronized(lockObject) 块时,锁的选择完全取决于 lockObject 的值。若传入 this,则等同于实例方法锁;若传入 ClassName.class,则等同于静态方法锁。一个常见的问题是混淆两者导致死锁或无效同步。例如,若在实例方法中用 synchronized(MyClass.class),则实际上是在竞争类锁,这会与其他静态同步方法冲突,即使它们操作的是不同实例。反之,若在静态方法中用 synchronized(this),由于静态方法没有 this,这是非法的,编译器会报错。因此,必须严格根据需要同步的资源范围选择锁对象:实例级用 this,类级用 Class 对象。

















