views:

320

answers:

5

I understand that double locking in Java is broken, so what are the best ways to make Singletons Thread Safe in Java? The first thing that springs to my mind is:

class Singleton{
    private static Singleton instance;

    private Singleton(){}

    public static synchronized Singleton getInstance(){
        if(instance == null) instance = new Singleton();
        return instance;
    }
}

Does this work? if so, is it the best way (I guess that depends on circumstances, so stating when a particular technique is best, would be useful)

+11  A: 

Josh Bloch recommends using a single-element enum type to implement singletons (see Effective Java 2nd Edition, Item 3: Enforce the singleton property with a private constructor or an enum type).

Some people think this is a hack, since it doesn't clearly convey intent, but it does work.

The following example is taken straight from the book.

public enum Elvis {
   INSTANCE;

   public void leaveTheBuilding() { ... }
}

Here is his closing arguments:

This approach [...] is more concise, provides the serialization machinery for free, and provides an ironclad guarantee against multiple instantiations, even in the face of sophisticated serialization or reflection attacks. While this approach has yet to be widely adopted, a single-element enum type is the best way to implement a singleton.


On enum constant singleton guarantee

JLS 8.9 Enums

An enum type has no instances other than those defined by its enum constants.

It is a compile-time error to attempt to explicitly instantiate an enum type. The final clone method in Enum ensures that enum constants can never be cloned, and the special treatment by the serialization mechanism ensures that duplicate instances are never created as a result of deserialization. Reflective instantiation of enum types is prohibited. Together, these four things ensure that no instances of an enum type exist beyond those defined by the enum constants.


On lazy initialization

The following snippet:

public class LazyElvis {
    enum Elvis {
        THE_ONE;
        Elvis() {
            System.out.println("I'M STILL ALIVE!!!");
        }       
    }
    public static void main(String[] args) {
        System.out.println("La-dee-daaa...");
        System.out.println(Elvis.THE_ONE);
    }
}

Produces the following output:

La-dee-daaa...
I'M STILL ALIVE!!!
THE_ONE

As you can see, THE_ONE constant is not instantiated through the constructor until the first time it's accessed.

polygenelubricants
Does the client have specific control of when the singleton is initialized?
aioobe
does this work with lazy initialisation? if so how?
Robert
@Robert I think that, because Elvis is an inner-class, Elvis.THE_ONE is not instantiated until it is called. I think this is a special property of inner-classes...if Elvis were a "regular" outer-class, then Elvis.THE_ONE would be instantiated as soon as the application started. Someone please correct me if I'm wrong.
Michael Angstadt
@mangst: I did some experimentation, and actually my test above is not conclusive at all, and may in fact be misleading. Enum constants are lazily constructed, but it's a bit more complicated than that. I'd suggest combining the `enum` with the initialization on demand holder idiom linked by aioobe. Having said that, Bloch argues that lazy initialization isn't a good optimization. It adds unnecessary complexity, is error prone, and rarely improves performance. _Effective Java 2nd Edition, Item 71: Use lazy initialization judiciously_.
polygenelubricants
@polygenelubricants What do you mean by "it's a bit more complicated than that"? The Elvis() constructor isn't run until Elvis.THE_ONE is called. Isn't that lazy initialization?
Michael Angstadt
@mangst: the constructor is run when `Elvis` has a `static` initializer block. Or if it has a `static` method, and you call that, even though it has nothing to do with the constants. These are just preliminary results from my own unstructured experimentation.
polygenelubricants
+2  A: 

Josh Bloch recommends 2 solutions:

1) worser:

class Singleton {

   public static Singleton instance = new Singleton();

   ...
}

2) better:

public enum Singleton {

   INSTANCE;

   ...
}
Roman
+4  A: 

I see no problem with your implementation (other than the fact that the lock for the singleton-monitor may be used by other methods, for other reasons, and thus, unnecessarily, prevent some other thread from getting the instance). This could be avoided by introducing an extra Object lock to lock on.

This Wikipedia article suggests another method:

public class Something {
    private Something() {
    }

    private static class LazyHolder {
        private static final Something INSTANCE = new Something();
    }

    public static Something getInstance() {
        return LazyHolder.INSTANCE;
    }
}

From the article:

This implementation is a well-performing and concurrent implementation valid in all versions of Java.
...
The implementation relies on the well-specified initialization phase of execution within the Java Virtual Machine (JVM); see section 12.4 of Java Language Specification (JLS) for details.

aioobe
yep, this one is better. Because until you access the static inner class' variable `INSTANCE`, it will not be initialized (lazy). And that initialization is only once.thanks.
Paarth
+3  A: 

My preference is to just do:

class Singleton {
    private static final INSTANCE = new Singleton();

    private Singleton(){}

    public Singleton instance(){
        return INSTANCE;
    }
 }

It is rare that you need lazy initialization. You should always start with eager initialization and only change to lazy initialization if you see problems. Unless you have measured and pinpointed Singleton instantiation as the culprit of performance problem, just use eager initialization. It's simpler and more performant.

You could use enum for sure, but personally I don't bother because the benefit over normal eager instantiation is security (against reflection attack), and most of the time my code is vulnerable to such attacks anyways :p

Enno Shioji
A: 

You can use this snippet of code from wiki

public class Singleton {
   // Private constructor prevents instantiation from other classes
   private Singleton() {}

   /**
    * SingletonHolder is loaded on the first execution of Singleton.getInstance() 
    * or the first access to SingletonHolder.INSTANCE, not before.
    */
   private static class SingletonHolder { 
     private static final Singleton INSTANCE = new Singleton();
   }

   public static Singleton getInstance() {
     return SingletonHolder.INSTANCE;
   }
 }
VinAy
this has already been suggested in another answer!
Robert