What is an efficient way to implement a singleton pattern in Java?

java

singleton

design-patterns

best-practices

byAnton Shumikhin·Aug 11, 2024

An Enum-based singleton is the preferred way to implement a singleton pattern in Java. It assures thread safety, protection against multiple instantiations, and is serialization-resistant. Declare an enum with a single element:

public enum Singleton {
    INSTANCE;
    // optional instance methods go here
    public void execute() {
        // my code here is fire 🔥
    }
}

Wanna call it? Java has you covered with its full singleton guarantees:

Singleton.INSTANCE.execute();  // rock solid, baby!

In certain scenarios where enums don't cut it or if you're using Java 5 or earlier, there are still ways to ensure serialization handling, lazy-initialization, and protection against singleton vulnerabilities.

Digging deeper: Robust singleton variants

Serializable singleton: handle with care!

To make your singleton play well with serialization, make sure your class implements Serializable, and embrace the magic of the readResolve() method. It keeps the singleton promise alive post deserialization:

protected Object readResolve() {
    return INSTANCE;
    //.instantiation nightmares averted! Close one, eh?
}

Reflective attack-proofing your singleton

In a world where reflection can create new instances of your cherished singleton, show who's boss:

private Singleton() {
    if (INSTANCE != null) {
        throw new IllegalStateException("Already instantiated... Don't be greedy!");
    }
}

Lazy-loaded singletons: Better late than never!

Borrow the Initialization-on-demand holder idiom by encapsulating the instance inside a private static class:

public class Singleton {
    private Singleton() {}
    
    private static class LazyHolder {
        private static final Singleton INSTANCE = new Singleton();
        // First one here gets the prize! 🎉
    }
    
    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
        // "I'll be back!" - Terminator style
    }
}

Volatile singletons: Nallely's favorites

Sometimes, you just need to go nuclear. Declaring your instance as volatile adds an extra layer of singleton protection:

private static volatile Singleton instance;

public static Singleton getInstance() {
    // "Hold up, we're checking for intruders!" - Security Team
    if (instance == null) {
        synchronized (Singleton.class) {
            if (instance == null) {
                instance = new Singleton();
            }
        }
    }
    return instance;
}

But don't forget, wielding this power requires understanding the modern Java Memory Model.

Advanced techniques: Singleton Black Belt

Load time: Choose wisely

Remember, with great loading time options, come great responsibilities:

Embark on the path of Early loading when the application starts and keep the singleton instance ready.
Take the Lazy Loading route for instances that are heavy and which don't really need to be instant right out the gate.

Each loading choice impacts resource usage and should be made judiciously.

Pugh's magic: Modern singleton solution

If enums don't rock your boat, let's take a spin with Bill Pugh's Singleton solution. It combines all the goodness without the drama!

public class Singleton {
    private Singleton() {}

    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
        // "Whew! That was a lot of typing!" - Your Fingers
    }

    public static Singleton getInstance() {
        return Holder.INSTANCE;
        // "Fine, here you go!" - Singleton class
    }
}