java - 为什么 `synchronized (lock)`被不同的线程输入两次？

Question

在这个简单的示例中，我有两个由不同线程访问的同步 (theLock)

public class Main {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("start");

        final Object theLock = new Object();

        synchronized (theLock) {
            System.out.println("main thread id : " + Thread.currentThread().getId());

            new Thread(() -> {
                System.out.println("new thread id : " + Thread.currentThread().getId() + ". Inside thread");

                // before entering this section new thread should be blocked as `theLock` is already acquired
                synchronized (theLock) {
                    System.out.println("inside synchronized");
                    theLock.notify();
                }
            }).start();

            theLock.wait();
        }

        System.out.println("end");
    }
}

为什么新创建的线程可以访问到里面的synchronized(theLock)段？据我了解，theLock 已经被主线程获取，新的应该永远阻塞。相反，我看到它也进入了synchronized。

这是一个输出

start
main thread id : 1 
new thread id : 13. Inside thread
inside synchronized
end

Answer 1

调用 wait() 会释放锁。 Per wait() Javadoc (加粗我的):

Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.