synchronized锁的是谁，看完这篇就明白了

synchronized关键字锁定的不是某个具体的对象或代码，而是一个“对象”所关联的“监视器锁（Monitor Lock）”​。

我们可以从三个不同的使用场景来理解它到底锁的是谁：

---

1. 同步实例方法 (synchronized instance method)

​锁的是：调用该方法的当前实例对象（即 this）​​

public class Counter {
    private int count = 0;
    
    // 同步实例方法
    public synchronized void increment() {
        count++;
    }
}

​解释​：

当一个线程调用 counter1.increment()时，它获取的是 counter1这个对象实例的锁。另一个线程如果也想调用 counter1的任何同步实例方法（比如另一个 synchronized void decrement()），它会被阻塞。

但是，如果另一个线程调用的是 counter2.increment()（另一个实例），那么它获取的是 counter2的锁，与 counter1的锁无关，所以两个线程可以同时执行，不会阻塞。

​结论​：实例级别的锁，不同实例的锁互不干扰。

---

2. 同步静态方法 (synchronized static method)

​锁的是：该类的 Class对象​

public class Counter {
    private static int count = 0;
    
    // 同步静态方法
    public static synchronized void increment() {
        count++;
    }
}

​解释​：

静态方法是属于类的，而不是任何单个实例。因此，锁住的是 Counter.class这个类对象。

无论有多少个 Counter实例，只要一个线程进入了 Counter.increment()方法，其他所有线程都不能进入任何一个同步静态方法（因为它们都需要获取 Counter.class的锁）。但它不会阻塞同步实例方法（因为它们锁的是 this）。

​结论​：类级别的全局锁，所有实例共享。

---

3. 同步代码块 (synchronized block)

​锁的是：括号 (()) 中配置的对象​

public class Counter {
    private int count = 0;
    private final Object lock = new Object(); // 专门用作锁的对象
    
    public void increment() {
        // 同步代码块，锁的是lock对象
        synchronized (lock) {
            count++;
        }
    }
    
    public void doSomething() {
        // 同步代码块，锁的是当前实例 this
        synchronized (this) {
            // ...
        }
    }
    
    public static void staticMethod() {
        // 同步代码块，锁的是类的Class对象
        synchronized (Counter.class) {
            // ...
        }
    }
}

​解释​：

这是最灵活的方式，你可以显式地指定要锁哪个对象。

• synchronized (lock)：锁的是 lock这个对象实例。

• synchronized (this)：效果等同于同步实例方法，锁的是当前实例。

• synchronized (Counter.class)：效果等同于同步静态方法，锁的是类对象。

​结论​：锁的是你明确指定的那个对象。

---

核心总结与记忆口诀

使用方式	锁的对象	备注
synchronized实例方法	​调用该方法的对象实例​（this）	锁对象实例
synchronized静态方法	​类的Class对象​（如 MyClass.class）	全局锁，影响所有实例
synchronized(obj)代码块	​括号里配置的对象​（obj）	最灵活，可以任意指定锁对象

​一句话概括​：​synchronized锁的是进入同步代码/方法前需要获取的那个“对象监视器锁”。​​

重要特性

1. ​可重入性 (Reentrant)​​：同一个线程可以多次获取同一把锁。例如，在一个 synchronized方法内部可以调用另一个 synchronized方法而不会死锁。

2. ​互斥性 (Mutual Exclusion)​​：一把锁一次只能被一个线程持有，其他想要获取同一把锁的线程会被阻塞（BLOCKED），直到锁被释放。

3. ​保证可见性 (Visibility)​​：遵循 happens-before 原则，在释放锁之前对共享变量所做的修改，对后续获取同一把锁的线程是可见的。

4. ​不可中断性​：一个线程在等待获取锁的过程中不能被中断（这一点与 Lock接口不同）。

理解 synchronized锁的是哪个对象，是正确使用它并避免并发问题（如死锁、数据竞争）的关键。