Java Program to Demonstrate the Lazy Initialization Non-Thread-Safe

In Java, lazy initialization is a technique where an object is only created once it is first needed. Utilizing such a method can be beneficial for objects that are expensive to create or may not be needed at all. However, lazy initialization might cause issues in multithreaded applications. It is because multiple threads may try to access the object simultaneously, and if the object is not thread-safe, this can lead to data corruption.

Approach: Lazy Initialization with Non-Thread-Safe

The code uses the volatile keyword to make the instance variable thread-safe. The volatile keyword makes sure that every thread sees the instance variable's most recent value. The synchronized keyword is used to lock the Singleton.class object when the getInstance() method is called. It makes sure that only one thread at once may use the getInstance() method.

Algorithm:

Define a Singleton class with a private static instance variable.
Implement a private constructor for the Singleton class to prevent direct instantiation.
The Singleton class should include a getInstance() method.
- Verify whether the instance is null.
- If the instance is null, create a new instance and assign it to the instance.
- Return the instance.
Implement a displayMessage() method in the Singleton class to print a message.
Create a LazyInitialization class with the main() method.
Inside the main() method:
- Create three threads with t1, t2, and t3.
- Each thread's run() method calls getInstance() and displayMessage() methods.
- Start the execution of all three threads.
End the program execution.

Note: The code demonstrates the lazy initialization non-thread-safe approach, where multiple threads can potentially create multiple instances of the singleton class.

Implementation:

Filename: LazyInitialization.java

//The program demonstrates the lazy initialization of non-thread-safe.
class Singleton {
    private static Singleton instance;

    // Private constructor to prevent instantiation.
    private Singleton() {
        System.out.println("Singleton object created");
    }

    // Gets the singleton instance.
    //@return The singleton instance.
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    //Prints a message.
    public void displayMessage() {
        System.out.println("Lazy Initialized Singleton");
    }
}

public class LazyInitialization {

    public static void main(String[] args) {
        // Create three threads.
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // Get the singleton instance.
                Singleton singleton = Singleton.getInstance();

                // Display a message.
                singleton.displayMessage();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // Get the singleton instance.
                Singleton singleton = Singleton.getInstance();

                // Display a message.
                singleton.displayMessage();
            }
        });

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                // Get the singleton instance.
                Singleton singleton = Singleton.getInstance();

                // Display a message.
                singleton.displayMessage();
            }
        });

        // Start the three threads.
        t1.start();
        t2.start();
        t3.start();
    }
}

Output:

Singleton object created
Lazy Initialized Singleton
Singleton object created
Lazy Initialized Singleton
Singleton object created
Lazy Initialized Singleton

Explanation: The getInstance() method could be more efficient using the double-checked locking pattern. The pattern avoids the overhead of locking the getInstance() method every time it is called. The Singleton class could be made more reusable by making it abstract. It would allow other classes to extend the Singleton class and inherit its lazy initialization behavior. The Singleton class could be made more extensible by providing a way for subclasses to customize the getInstance() method. It would allow subclasses to control how the Singleton object is created.

Next TopicJava Program to Demonstrate the Non-Lazy Initialization Thread-Safe

← prev next →