Thanks for quick response. Definitely We can simulate partially constructed objects for collaborations (listeners, parent-child bidirectional relations).

Cheers

Sorry talking about this topic after one year… I have a small request. Can you write an example code which shows that double checked locking might create partially singleton object ?

I’m asking this question because I have just read information below from jvm spec…

******Just before a reference to the newly created object is returned as the result*****, the indicated constructor is processed to initialize the new object using the following procedure:

1. Assign the arguments for the constructor to newly created parameter variables for this constructor invocation.
2. If this constructor begins with an explicit constructor invocation of another constructor in the same class (using this), then evaluate the arguments and process that constructor invocation recursively using these same five steps. If that constructor invocation completes abruptly, then this procedure completes abruptly for the same reason; otherwise, continue with step 5.
3. This constructor does not begin with an explicit constructor invocation of another constructor in the same class (using this). If this constructor is for a class other than Object, then this constructor will begin with an explicit or implicit invocation of a superclass constructor (using super). Evaluate the arguments and process that superclass constructor invocation recursively using these same five steps. If that constructor invocation completes abruptly, then this procedure completes abruptly for the same reason. Otherwise, continue with step 4.
4. Execute the instance initializers and instance variable initializers for this class, assigning the values of instance variable initializers to the corresponding instance variables, in the left-to-right order in which they appear textually in the source code for the class. If execution of any of these initializers results in an exception, then no further initializers are processed and this procedure completes abruptly with that same exception. Otherwise, continue with step 5. (In some early implementations, the compiler incorrectly omitted the code to initialize a field if the field initializer expression was a constant expression whose value was equal to the default initialization value for its type.)
5. Execute the rest of the body of this constructor. If that execution completes abruptly, then this procedure completes abruptly for the same reason. Otherwise, this procedure completes normally.

What I understood from this is JVM will not return a reference which is not fully constructed.

Note: I read the book you mentioned. And There was no example about partially constructed object in case of double checked locking.

public class InitTest {

  public static void main(String arg[]) {
    System.out.println("Force singleton class to load");
    Singleton.test();

    System.out.println("ngetInstance1");
    Singleton.getStaticInstance();

    System.out.println("ngetInstance2");
    Singleton.getHolderInstance();
  }
}

class Singleton {
  static {
    System.out.println("Loading Singleton class");
  }

  private static Singleton s1 = new Singleton();

  private static class SingletonHolder {
    static final Singleton s2 = new Singleton();
  }

  Singleton() {
    System.out.println("Constructing Singleton");
  }

  public static Singleton getStaticInstance() {
    return s1;
  }

  public static Singleton getHolderInstance() {
    return SingletonHolder.s2;
  }

  public static void test() {
    // do nothing with s1 or s2
  }
}

which when run prints:

Force singleton class to load
Loading Singleton class
Constructing Singleton

getInstance1

getInstance2
Constructing Singleton

As you can see, calling the static Singleton.test() method causes s1 to be loaded in the static variable, but s2 is not constructed until it is actually asked for, so the “initialize on demand” idiom is slightly lazier. But, I admit that this scenario is probably not common and that most singleton classes have just a static getInstance() which will effectively behave the same with either a static variable or an “initialize on demand” class.