---
obj: concept
---
# Singleton Pattern

## **Description:**
The Singleton Pattern is a creational design pattern that ensures a class has only one instance and provides a global point of access to that instance. It is commonly used when you want to restrict the instantiation of a class to a single object and control access to that unique instance across the application.

**How it's Used:**
1. **Private Constructor**: Ensure that the class has a private constructor to prevent direct instantiation from external code.
2. **Static Instance**: Create a static instance of the class within the class itself.
3. **Lazy or Eager Initialization**: Decide whether to initialize the instance lazily (on-demand) or eagerly (at the time of class loading). Lazy initialization is preferred if resource usage should be minimized.
4. **Static Method**: Provide a static method within the class to access the unique instance. This method should handle the creation of the instance if it doesn't exist or return the existing instance.
5. **Thread Safety (Optional)**: If your application is multithreaded, ensure that the creation of the instance and access to it is thread-safe, especially if using lazy initialization.

## **Example:**
A classic example of the Singleton Pattern is creating a configuration manager that provides access to application-wide configuration settings:

```java
public class ConfigurationManager {
    private static ConfigurationManager instance; // Static instance variable
    private String configurationData;

    // Private constructor to prevent external instantiation
    private ConfigurationManager() {
        // Initialize configurationData from a configuration file or other source
        configurationData = "Default configuration";
    }

    // Static method to provide access to the unique instance
    public static ConfigurationManager getInstance() {
        if (instance == null) {
            instance = new ConfigurationManager(); // Lazy initialization
        }
        return instance;
    }

    public String getConfigurationData() {
        return configurationData;
    }

    public void setConfigurationData(String data) {
        configurationData = data;
    }
}
```

In this Java example:
- The `ConfigurationManager` class has a private constructor to prevent external instantiation.
- It contains a private static instance variable.
- The `getInstance` static method is used to access the unique instance of the class. It initializes the instance lazily when called for the first time.
- You can use `ConfigurationManager.getInstance()` to access the configuration manager from anywhere in your application.

```java
public class Main {
    public static void main(String[] args) {
        ConfigurationManager configManager1 = ConfigurationManager.getInstance();
        ConfigurationManager configManager2 = ConfigurationManager.getInstance();

        // Both instances refer to the same unique object
        System.out.println(configManager1 == configManager2); // true

        // Access and modify configuration data
        System.out.println(configManager1.getConfigurationData()); // Default configuration
        configManager1.setConfigurationData("New configuration");
        System.out.println(configManager2.getConfigurationData()); // New configuration
    }
}
```

The Singleton Pattern ensures that there's only one instance of `ConfigurationManager` throughout the application, providing a centralized and controlled way to manage configuration data.