Question

Possible Duplicate:
Efficient way to implement singleton pattern in Java

I was reading this Best Singleton Implementation In Java, but its not thread safe.

As per wiki :

if(singleton==null) {
synchronized(Singleton.class) { //
this is needed if two threads are
waiting at the monitor at the // time
when singleton was getting
instantiated if(singleton==null)
singleton= new Singleton(); }
}


But Find Bugs utility gives two errors in this :
1. Double null check.
2. Incorrect lazy initialization of static field.

What is the best way,

Is it Correct :

synchronized (Singleton.class) {
if (singleton== null) {
singleton= new Singleton();
}
}

Answer 1

The most efficient/simplest way to make a lazy loading Singleton is just

enum Singleton {
   INSTANCE
}

Note: there is no need for locking as class loading is thread safe. The class is final by default and the constructor cannot be called via reflection. The INSTANCE will not be created until the INSTANCE, or the class is used. If you are worried the class might be accidentally used you can wrap the singleton in an inner class.

final class Singleton {
    private Singleton() { }
    static class SingletonHolder {
        static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

IMHO, you have to be pretty paranoid to consider this a better solution.