Singleton Design Pattern

What is the Singleton Pattern?

The Singleton is a creational design pattern that ensures a class has only one instance throughout the application's lifecycle while providing a global point of access to that instance.

This pattern is useful when exactly one object is needed to coordinate actions across the system.

Why Use the Singleton Pattern?

Imagine an application where multiple components need to write logs or access configuration settings. If every component creates its own logger or configuration object, it can lead to:

Increased memory usage
Inconsistent configuration values
Difficulties in managing shared resources

The Singleton pattern solves this by ensuring there is only one shared instance.

Real-World Analogy

Think of the president of a company. There is only one president at a time. Whenever employees need approval, they all communicate with the same person instead of creating a new president for each request.

Similarly, in software, every part of the application accesses the same Singleton object.

Structure

The Singleton class typically includes:

A private static variable that stores the single instance.
A private constructor to prevent direct object creation.
A public static method that returns the single instance.
Java Example
public class Singleton {

// Create a single instance
private static Singleton instance;

// Private constructor prevents object creation
private Singleton() {
}

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

public void displayMessage() {
    System.out.println("Singleton instance is working!");
}

}

Using the Singleton
public class Main {
public static void main(String[] args) {

    Singleton obj1 = Singleton.getInstance();
    Singleton obj2 = Singleton.getInstance();

    obj1.displayMessage();

    System.out.println(obj1 == obj2);
}

}

Output
Singleton instance is working!
true

The output true indicates that both obj1 and obj2 reference the same object.

Advantages
Ensures only one instance exists.
Saves memory by avoiding unnecessary object creation.
Provides a single access point for shared resources.
Useful for logging, caching, configuration, and database connection management.
Disadvantages
Introduces global state, which can make testing more difficult.
Can create tight coupling between classes.
Requires careful implementation in multithreaded environments to avoid creating multiple instances simultaneously.
Common Use Cases

The Singleton pattern is commonly used for:

Logger services
Configuration managers
Cache managers
Printer spoolers
Database connection managers (or more commonly today, managing a shared connection pool)
Conclusion

The Singleton pattern is one of the simplest and most widely used design patterns. It guarantees that only one instance of a class exists and provides a centralized way to access it. While it is useful for managing shared resources, it should be applied only when a single shared instance is genuinely required.