java synchronized 递归,同步方法以递归方式调用自身。这打破了吗？

The point of this question is to illustrate that Java is not working as I expected.

How would you expect the following code to behave?

public class SynchTester {

private static SynchTester synchTester;

public synchronized static SynchTester getSynchTester(){

if(synchTester==null){

synchTester = new SynchTester();

}

return synchTester;

}

private SynchTester() {

SynchTester myTester = getSynchTester();

}

public static void main(String[] args) {

SynchTester tester = SynchTester.getSynchTester();

}

}

I would expect it to hang with a deadlock waiting on the recursion to complete, but instead it throws StackOverflow. Evidently synchronized does not block access to the same thread.

Is this a bug?

解决方案

In Java, synchronized locks are reentrant.

Recall that a thread cannot acquire a lock owned by another thread. But a thread can acquire a lock that it already owns. Allowing a thread to acquire the same lock more than once enables reentrant synchronization. This describes a situation where synchronized code, directly or indirectly, invokes a method that also contains synchronized code, and both sets of code use the same lock. Without reentrant synchronization, synchronized code would have to take many additional precautions to avoid having a thread cause itself to block.

Source: see bottom of this page