Singleton pattern interview

Question

I am recently asked about java related question in an interview with following code, since I am very new to java and barely code in Java so I really have no idea what the following code does.

The question was Select the option that describes the worst thing with the following code:

public class Bolton {
    private static Bolton INST = null;

    public static Bolton getInstance()
    {
        if ( INST == null )
        {
            INST = new Bolton();
        }
        return INST;
    }

    private Bolton() {
    }
}

Here are the options for this question

1. More than one instance of Bolton can be created
2. A Bolton will never be created
3. The constructor is private and can't be called
4. Value can be garbage collected, and the call to getInstance may return garbage data

Which of the above options is correct? And Why?

Answer 1

This is a Singleton Pattern

The idea of a Singleton Pattern is to only have one available instance of a class. Therefore the constructor is set to private and the class maintains, in this case, a getInstance() method that either calls an existing instance variable, INST in this class, or creates a new one for the executing program. The answer is probably 1, because it's not thread safe. It may be confused for 3, which I had put down earlier, but that is by design, technically, so not actually a flaw.

Here's an example of Lazy Initialization, thread-safe singleton pattern from Wikipedia:

public class SingletonDemo {

    private static volatile SingletonDemo instance = null;

    private SingletonDemo() {  } 

    public static SingletonDemo getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo.class){
                if (instance == null) {
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }

}

Setting the instance variable to volatile tells Java to read it from memory and to not set it in cache.

Synchronized statements or methods help with concurrency.

Read more about double checked locking which is what happens for a "lazy initialization" singleton

Answer 2

More than one instance of Bolton can be created

This option is correct due to lack of synchronization in the above code.

Suppose two threads concurrently check for null and both will find that the value is null and both will call the constructor (which refutes singleton).

Also there is other catch in this, even if two threads dont check for null together but suppose one thread calls the constructor; but the constructor wont return till the object is constructed (assuming that the object is costly to create and requires time), so till the constructor returns some other thread might check for the null condition and still find the object as null as the object is not yet constructed.

This scenario in which some pre condition is called check-then-act which is culprit for Race.

For singleton there are two standards that are being used:

• Double Checked locking
• Enum based singleton pattern

UPDATE: Here is another great article which discusses the double checked locking