The Singleton pattern belongs to the category of creational design patterns. It restricts the instantiation of a class to a single object and provides a global point of access to that instance. This approach is particularly useful when exactly one object is needed to coordinate actions across a system.

By controlling the instantiation process, the Singleton pattern ensures that resources are managed efficiently and that multiple parts of an application reference the same object instance. This is especially important for resource-intensive classes such as database connection pools, configuration managers, or logging systems. However, careful consideration must be given to thread safety in multi-threaded environments.

Basic Singleton Implementation

Consider a Logger class implemented as a Singleton:

public class Logger {
    // Eagerly created instance
    private static Logger instance = new Logger();
    
    // Private constructor prevents external instantiation
    private Logger() {
    }
    
    // Static factory method for global access
    public static Logger getInstance() {
        return instance;
    }
    
    public void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

Client code demonstrating the Singleton behavior:

public class Application {
    public static void main(String[] args) {
        Logger firstLogger = Logger.getInstance();
        Logger secondLogger = Logger.getInstance();
        
        // Both references point to the same instance
        if (firstLogger == secondLogger) {
            System.out.println("Identical instances confirmed");
        }
        
        firstLogger.log("System initialized");
    }
}

The above example uses eager initialization, where the instance is created at class loading time. Alternative approaches include lazy initialization, reflection-based instantiation, or serialization-based reconstruction, depending on specific requirements.

Thread-Safe Singleton with Double-Checked Locking

For applications running in multi-threaded environments, a thread-safe implementation is essential:

public class ConfigurationManager {
    private static volatile ConfigurationManager configInstance;
    
    private ConfigurationManager() {
    }
    
    public static ConfigurationManager getInstance() {
        if (configInstance == null) {
            synchronized (ConfigurationManager.class) {
                if (configInstance == null) {
                    configInstance = new ConfigurationManager();
                }
            }
        }
        return configInstance;
    }
}

Key Principles

The Singleton pattern enforces the following requirements:

1. Single Instance Guarantee: The class constructor is declared private, preventing external instantiation. Only the class itself can invoke the constructor.
2. Global Access Point: A static method provides access to the sole instance, allowing any part of the application to retrieve it.
3. Thread Safety: In concurrent environments, double-checked locking with the volatile keyword ensures that only one instance is created even when multiple threads attempt simultaneous access.

Class Diagram

The Singleton class structure typically contains:

• A private static field holding the single instance
• A private constructor
• A public static method returning the instance