Singleton pattern with combination of lazy loading and thread safety

Question

I was doing some research about singletons, specifically regarding lazy vs eager initialization of singletons.

An example of eager initialization:

public class Singleton {     //initialzed during class loading     private static final Singleton INSTANCE = new Singleton();      //to prevent creating another instance of Singleton     private Singleton(){}      public static Singleton getSingleton(){         return INSTANCE;     } } 

but as shown above that it is eager initialization and thread safety is left to jvm but now, I want to have this same pattern but with lazy initialization.

so I come up with this approach:

public final class Foo {     private static class FooLoader {         private static final Foo INSTANCE = new Foo();     }     private Foo() {         if (FooLoader.INSTANCE != null) {             throw new IllegalStateException("Already instantiated");         }     }     public static Foo getInstance() {         return FooLoader.INSTANCE;     } } 

As shown above Since the line

private static final Foo INSTANCE = new Foo();  

is only executed when the class FooLoader is actually used, this takes care of the lazy instantiation, and is it guaranteed to be thread safe.

Is this correct?

Answer 1

Your second code snippet is, in my opinion, the best way of thread-safe lazily initializing a singleton. It actually has a pattern name

Initialization-on-demand holder idiom

I would suggest you use it.

Answer 2

You first design is actually lazy. Think about it, the instance is only created when the class is initialized; the class is only initialized when the getSingleton() method is called [1]. So the instance is only created when it's asked for, i.e. it's lazily created.

[1] http://docs.oracle.com/javase/specs/jls/se7/html/jls-12.html#jls-12.4.1