Understanding Singleton Classes in Java and Their Implementations

What is a singleton class in Java? And How to implement a singleton class?

A singleton class in Java is a design pattern that restricts the instantiation of a class to a single instance. This is useful when exactly one object is needed to coordinate actions across the system. The singleton pattern ensures that a class has only one instance and provides a global point of access to that instance.

Key Characteristics of a Singleton Class:

1. Private Constructor: The constructor of the class is made private to prevent instantiation from outside the class.
2. Static Instance: A static variable holds the single instance of the class.
3. Public Static Method: A public static method (often named getInstance()) provides access to the instance.

Implementation of a Singleton Class

Here are a few common ways to implement a singleton class in Java:

1. Eager Initialization

In this approach, the instance of the class is created at the time of class loading.

public class Singleton {
    // Eagerly create the instance
    private static final Singleton instance = new Singleton();

    // Private constructor
    private Singleton() {}

    // Public method to provide access to the instance
    public static Singleton getInstance() {
        return instance;
    }
}

2. Lazy Initialization

In this approach, the instance is created only when it is needed.

public class Singleton {
    // Private static variable to hold the single instance
    private static Singleton instance;

    // Private constructor
    private Singleton() {}

    // Public method to provide access to the instance
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

3. Thread-Safe Singleton (Double-Checked Locking)

This approach is thread-safe and uses double-checked locking to reduce the overhead of acquiring a lock.

public class Singleton {
    private static volatile Singleton instance;

    // Private constructor
    private Singleton() {}

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

4. Bill Pugh Singleton Design

This approach uses a static inner helper class to hold the singleton instance. The instance is created only when the getInstance() method is called.

public class Singleton {
    // Private constructor
    private Singleton() {}

    // Static inner class responsible for holding the singleton instance
    private static class SingletonHelper {
        private static final Singleton INSTANCE = new Singleton();
    }

    // Public method to provide access to the instance
    public static Singleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}

Summary

• A singleton class ensures that only one instance of the class exists.
• It can be implemented using various methods, including eager initialization, lazy initialization, thread-safe singleton, and the Bill Pugh method.
• The choice of implementation depends on the specific requirements, such as thread safety and performance considerations.