子类继承父类，重写父类的synchronized方法，两个synchronized方法的锁对象的问题

这是java并发编程实践中有关重入概念的介绍时产生的问题

public class Widget {  
    public synchronized void doSomething() {  
        ...  
    }  
}  
  
public class LoggingWidget extends Widget {  
    public synchronized void doSomething() {  
        System.out.println(toString() + ": calling doSomething");  
        super.doSomething();  
    }  
}

子类继承父类，重写父类的synchronized方法，两个synchronized方法的锁对象的问题

是同一个锁还是不同锁呢，是同一个锁的话是  父类对象作为锁还是子类对象作为锁呢？

以下是我从别的地方找到的检验代码，可以确定上述问题

public class Test {
  public static void main(String[] args) throws InterruptedException {
    final TestChild t = new TestChild();
 
    new Thread(new Runnable() {
      @Override
      public void run() {
        t.doSomething();
      }
    }).start();
    Thread.sleep(100);
    t.doSomethingElse();
  }
 
  public synchronized void doSomething() {
    System.out.println("something sleepy!");
    try {
      Thread.sleep(1000);
      System.out.println("woke up!");
    }
    catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
 
  private static class TestChild extends Test {
    public void doSomething() {
      super.doSomething();
    }
 
    public synchronized void doSomethingElse() {
      System.out.println("something else");
    }
  }
}

如果不是同一个锁，super锁住了父类对象，那么另一个线程仍然可以获得子类对象的锁。按照这个假设，以下程序应该输出
something sleepy!
something else
woke up!

但输出的是
something sleepy!
woke up!
something else

说明肯定是同一对象

另外main方法里最后那步执行的对象是子类，按着定义，谁调用方法谁作为锁，所以这个一定是子类对象，那么super.doSomething()这个方法一定也是子类对象，至于理解么：

可以认为即便是继承创建了父类对象，并把父类对象的引用交给了子类，但是在super.去调用方法的时候JVM认为调用者依然是子类。