The Perfect Singleton

From time to time I met Java programmers that are not really sure how they should implement Singleton pattern properly. (if you don’t have an idea what Singleton is just try Wikipedia: Singleton pattern).

And I’m not talking about proper implementation in threaded environment. But using the most common implementation you can find over internet you can easily create as many singletons as you like.

Just imagine you have the following common singleton implementation:

public final class NonSafeSingleton implements Serializable {

    private static final NonSafeSingleton INSTANCE = new NonSafeSingleton();

    private NonSafeSingleton() {}

    public static NonSafeSingleton getInstance() {
        return INSTANCE;
    }
}

Now concentrate on Serializable word. Think for one more second… Yes you’re right. If you send this stuff over RMI you’ll get second instance. It should even be enough to do some in memory serialization and de-serialization and kaboom! You’ve just blown away general Singleton contract. That’s not very nice. But how to fix that? Generally there are two ways I use:

1. The hard way (or you use 1.4 or older Java)
   You need to implement readResolve method in your Singleton class. This small thing is used to override what serialization mechanism has created. What you return there will be used instead of data that came from serialization (for details check: Serializable Javadoc). Just return your instance here:

   ...
       protected Object readResolve() throws ObjectStreamException {
           return INSTANCE;
       }
   ...

2. The easy way (Yes, I’m using 1.5 or newer)
   Change your singleton class to enum and remove private constructor and getInstance method. Yes it’s really that simple. You get this for free then.

   public enum SafeSingleton implements Serializable {
   
       INSTANCE;
   }

Just keep this in mind when implementing next Singleton. It can make your life easier if you use RMI heavily.