Can you write code to implement the Singleton design pattern in Java? What is the purpose of this pattern, and how do you ensure thread safety?

Answer :

The Singleton Design Pattern ensures that a class has only one instance throughout the application’s lifecycle, and it provides a global point of access to that instance. This pattern is commonly used in scenarios where you need a shared resource, such as a database connection or a logging system.

Purpose of Singleton Pattern:

• Single Instance: It restricts the instantiation of a class to a single object.
• Global Access: The single instance can be accessed globally throughout the application.
• Resource Management: Useful for shared resources like a database connection, configuration manager, logging service, etc.

Ensuring Thread Safety:

In a multi-threaded environment, if multiple threads attempt to create the instance of the class simultaneously, we may end up with multiple instances, which defeats the purpose of the Singleton pattern. To handle this, we need to ensure thread safety when creating the instance.

Code Example – Singleton Pattern with Thread Safety:

public class Singleton {

    // 1. Private static instance of the class 
    //(volatile to ensure visibility in a multithreaded environment)
    private static volatile Singleton instance;

    // 2. Private constructor to prevent instantiation from outside
    private Singleton() {
        // private constructor to prevent instantiation
    }

    // 3. Public method to provide access to the single instance 
   //(with synchronized block to ensure thread safety)
    public static Singleton getInstance() {
           // First check (No synchronization needed here)        
           if (instance == null) { 
                // Synchronizing the block to ensure only one thread can enter
                synchronized (Singleton.class) { 
                // Second check to avoid creating multiple instances
                if (instance == null) { 
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Explanation:

1. Private Static Instance:
   • The instance variable is marked as volatile to ensure visibility across multiple threads. The volatile keyword ensures that changes made to the instance are visible to all threads.
2. Private Constructor:
   • The constructor is made private so that no other class can directly instantiate this class. The only way to get an instance of the Singleton class is through the getInstance() method.
3. Lazy Initialization (Double-Checked Locking):
   • The getInstance() method ensures lazy initialization of the instance. It checks if the instance is null before attempting to create a new instance.
   • The double-check locking mechanism helps with thread safety:
     • The first check (outside the synchronized block) allows threads to avoid entering the synchronized block once the instance has been created.
     • The second check (inside the synchronized block) ensures that only one thread can initialize the instance if it was null.
4. Thread Safety:
   • The synchronized keyword is used to ensure that only one thread can create the instance at a time. The instance is created only when it’s null, and after that, any further calls to getInstance() will return the same instance without locking.