Answer by piet.t for Getting deadlock in java code

When BaseClass is referenced for the fist time the class loader kicks in and wants to set up the class for use. So it loads the class and starts the static initializer block

static {
    load();
}

This calls the load-method and there you try to create an object of type DerivedClass. This will first try to call the super()-constructor, i.e. a method of class BaseClass - but BaseClass isn't fully initialized yet because its static initializer has not completed => deadlock.

Edit: Based on your comment I did some more research. Actually, things are not quite as simple as I assumed. The JVM is capable of dealing with recursive initialization so there is no problem in the single-threaded case. A description of the class-initialization-process can be found in section 5.5 of the JVM-specification.

What is the culprit here is actually a race-condition between the two initialization-processes.

Thread 1 reaches DerivedClass.isSynthetic("test"), and starts the initialization of DerivedClass.

Meanwhile thread 2 reaches BaseClass.init()and starts the initialization of BaseClass.

While initializing DerivedClass thread 1 recognizes it has to initialize the superclass. Since initialization of BaseClass is already in progress by thread 2 thread 1 has to wait for it to complete.

While initializing BaseClass thread 2 reaches DerivedClass dc = new DerivedClass();. Since initialization of DerivedClass is already in progress by thread 1 thread 2 has to wait for it to complete.

So actually this is a classical deadlock where two threads try to enter two critical codepaths ("initialization of class X") in different order (BaseClass->DerivedClass vs. DerivedClass->BaseClass) and ending up waiting for each other.

Adding some Thread.sleep(100); in the proper places will also show you that this is really a race-condition. During my tests sometimes the program completed successfully despite the cyclic dependency during initialization.