Singleton Pattern

Singleton Pattern in Software Design

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.

Key Features of Singleton Pattern:

Single Instance – Only one object of the class is created.
Global Access Point – The instance is accessible globally.
Lazy Initialization (Optional) – The instance is created only when needed.
Thread Safety (Advanced) – Ensures multiple threads don’t create multiple instances.

When to Use the Singleton Pattern?

✅ Logging System – A single logger instance used across the application.
✅ Configuration Settings – A single object storing app settings.
✅ Database Connection – One connection object shared across the system.
✅ Thread Pools & Caches – Managing resources efficiently.

Key Elements in the Diagram

Singleton Class (Orange Box): This represents the class that implements the Singleton pattern. It contains the logic to ensure only one instance is created.
instance-1 (Gray Box): This represents the single instance of the Singleton class. It's created once and shared among all clients.
Client-1, Client-2, Client-3 (Blue Boxes): These represent clients or components in the system that need to use the Singleton instance.

Relationships Explained

Instantiation Control: The Singleton class (orange box) controls the creation of its instance. It typically does this by:
- Making the constructor private: This prevents direct instantiation from outside the class.
- Providing a static method (e.g., getInstance()) that returns the single instance. This method internally handles the creation of the instance (if it doesn't already exist) and then returns it.
Single Instance: The diagram emphasizes that there's only one instance-1 (gray box). Regardless of how many clients request the Singleton, they all receive the same instance.
Global Access Point: The getInstance() method (or similar) provides a global access point to the single instance. Any client can call this method to retrieve and use the Singleton.
Client Requests: The arrows from Client-1, Client-2, and Client-3 to the Singleton class represent requests for the Singleton instance (e.g., by calling getInstance()).
Shared Instance: The arrows from the Singleton class to instance-1 and then to each client show that all clients receive the same instance-1. They are all working with the same object in memory.

Example Scenario

Imagine you have a configuration manager in your application. You want only one configuration manager to exist to avoid conflicts and inconsistencies. The Singleton pattern is perfect for this. All parts of your application would call ConfigurationManager.getInstance() to get the single configuration manager instance.

Benefits of Singleton

Controlled Access: Ensures only one instance, preventing unintended creation of multiple objects.
Reduced Namespace: Avoids polluting the global namespace with unnecessary objects.
Easy Access: Provides a global point of access to the instance.

Drawbacks of Singleton

Can Mask Bad Design: Overuse can hide dependencies and make code harder to test.
Global State: Can introduce global state, making reasoning about the application's behavior more complex.
Tight Coupling: Can tightly couple classes, making them harder to reuse in different contexts.

In summary, the diagram illustrates how the Singleton pattern ensures one class has only one instance, and how all clients access that same instance through a centralized point of access. It's a powerful pattern, but it's important to use it judiciously and understand its potential drawbacks.

CODE IMPLEMENTATION in python:

class Singleton: _instance = None # Step 1: Private static variable def __new__(cls): if cls._instance is None: # Step 2: Create only one instance cls._instance = super(Singleton, cls).__new__(cls) print("Singleton Instance Created!") return cls._instance def show_message(self): print("Hello from Singleton Pattern!") # Step 3: Test the Singleton obj1 = Singleton() obj1.show_message() obj2 = Singleton() print(obj1 == obj2) # Output: True (Same instance)

Advantages of Singleton Pattern

✅ Memory Efficient – Avoids creating multiple instances.
✅ Centralized Control – Ensures controlled access to shared resources.
✅ Thread Safe (with modifications) – Ensures safe access in multi-threaded environments.

Singleton Pattern Example in Java

class Singleton { // Step 1: Create a private static instance private static Singleton instance; // Step 2: Private constructor to prevent instantiation private Singleton() { System.out.println("Singleton Instance Created!"); } // Step 3: Public method to provide global access to the instance public static Singleton getInstance() { if (instance == null) { // Lazy initialization instance = new Singleton(); } return instance; } public void showMessage() { System.out.println("Hello from Singleton Pattern!"); } } public class Main { public static void main(String[] args) { // Get the only instance of Singleton Singleton obj1 = Singleton.getInstance(); obj1.showMessage(); // Trying to create another instance Singleton obj2 = Singleton.getInstance(); // Checking if obj1 and obj2 are the same instance System.out.println(obj1 == obj2); // Output: true (Both references point to the same instance) } }

Output:


Singleton Instance Created!
Hello from Singleton Pattern!
true

The first time getInstance() is called, it creates a new instance.
Subsequent calls return the same instance instead of creating a new one.

Singleton Pattern