线程获取对象的监视器锁也获取超类的对象锁吗？

Question

当一个线程获得一个对象(比如类B)的监控锁时，它是否获得了属于它的超类(比如类A，其中B扩展了A)的对象的监控锁？

观察 #1 - 当一个线程（通过同步方法拥有派生对象 B 的监视器锁）在超类 A 中调用 wait（） 时，第二个线程获取对象 B 的监视器锁并在 A 中进行等待。最后，两个线程同时退出 B 的对象监视器。

我的理解是线程应该在其拥有锁的对象上调用wait（），否则这将导致非法监视器状态异常。在 A 的实例方法中调用 wait（） 时没有异常的原因，是否意味着拥有 B 对象锁的线程也拥有 A 对象的锁，它是超类？

关于同步的已检查文章

public class Obs2 {
    public static void main(String[] args) {
        A a = new B();
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(a);
        t1.start(); t2.start();
    }
}

class A implements Runnable {
    public void run() {
        try {
            wait(2000); // OK; No IllegalMonitorStateException
        } catch (InterruptedException e) {}
    }
}
class B extends A {
    @Override
    public synchronized void run() {
        super.run();
    }
}

观察#2-当线程（通过同步方法拥有对象a的监视器锁）在任意类C中调用wait（）时，它会引发IllegalMonitorStateException。

这表明线程在C的对象上调用wait（），而它拥有不同的对象A的锁。因此出现了例外。

public class Obs2 {
    public static void main(String[] args) {
        A a = new A();
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(a);
        t1.start(); t2.start();
    }

}

class A implements Runnable {
    public synchronized void run() {
        (new C()).display(this);
    }

}

class C {
    public void display() {
        try {
            wait(2000); //--> will lead to IllegalMonitorStateException
        } catch (InterruptedException e) {}
    }
}

为什么与任何其他类相比，对象监视器锁对超类的行为方式存在这种固有差异？

我对对象监视器锁的理解是否遗漏了什么？

Answer 1

我不确定你的问题是否有意义。没有“超类”实例这样的东西，因为子类的实例与其超类的实例相同，否则每次使用 new 关键字时都会实例化多个对象。这也是为什么你不能做这样的事情的原因：

synchronized (super) {
}

最终，使用等待和通知[全部]的能力属于Object（因为它们是最终方法），这是每个类的超超类。您可以将在this上同步视为在属于Object的监视器上同步，因为内在锁与对象而不是类相关联（一个重要的区别是可以获取与class对象相关联的内在锁）。

因此，由于 A 和 B 都是 Object 的同一实例，因此您在 B 中同步并从 A 调用 wait 并不重要，它们都引用同一个对象。