Singleton Design Pattern With Java Sample

What is Singleton Design Pattern?

 

Singleton design pattern is a creational design pattern. It is used to maintain single instance throughout the application.

 

When to use Single Design pattern?

 

When our requirement requires a single instance through the application and if it has to inherit by some other interface/class and if it needs memory management it should be dynamic and we can take steps to implement this design pattern.

 

If our aim is to create only single instance I recommend to use static class.

 

Where we can use it?

 

For Database connection, logging, caching purpose etc.

 

Rules to implement Singleton

1. It should have Global access
2. It should be not be inherited by some other class; i.e. we have to seal the class with Final key word / we can make constructor private to stop inheritance.
3. Constructor should be Private, to prevent the creation of instance from outside the class. And once we define constructor as private it will also help to stop being inherited. 

Below is the code which defined the Singleton design pattern. Below code is not thread safe.

package com.sdp;

public class SingletonSample {

    private static SingletonSample _instance;

    /// <summary>
    /// Instance will set only once initially when _insatnce is null
    /// </summary>
    public static SingletonSample getInstance() {
        if(_instance == null){
            _instance = new SingletonSample();
        }
        return _instance;
    }

    /// <summary>
    /// To prevent inheritance of this class and to prevent the creation of instance from outside the class
    /// </summary>
    private SingletonSample()
    {

    }
}

Below is the code to access singleton instance. To make sure we have single instance, I am accessing the class with Instance 10 times and matching with some refInstance object, along with printing object reference hash code 

package com.sdp;

import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {

       ArrayList<SingletonSample> singletonSamples=new ArrayList<SingletonSample>();

        for(int index=0;index<10;index++){
         singletonSamples.add((SingletonSample.getInstance()));
        }
        SingletonSample refInstance=SingletonSample.getInstance();
        System.out.println("refInstance object with Hashcode: " + refInstance.hashCode());
        singletonSamples.forEach(a->{
            if(a.equals(refInstance)){
                System.out.println("Found Same object with Hashcode: " +  a.hashCode());
            }else {
                System.out.println("Found different object with Hashcode: " +  a.hashCode());
            }
        });
    }
}

Below is the output snap of the above code

 

 

If we are using the threads in our application and we are expecting to maintain singleton instance even though the class is accessed by threads. In these kinds of cases we need thread safe singleton class.

 

Below is the thread safe code. 

package com.sdp;

public class ThreadSafeSingleton {

    private static ThreadSafeSingleton _instance;
    public static String Proposal;

    public static ThreadSafeSingleton getInstance(String proposal)
    {
        //synchronized keyword which will be used to synchronize threads
        synchronized  (ThreadSafeSingleton.class)
        {
            if (_instance == null)
            {
                Proposal = proposal;
                _instance = new ThreadSafeSingleton();
            }
        }
        return _instance;
    }

    private ThreadSafeSingleton()
    {

    }

    public void printPraposalName() {
         System.out.println(Proposal + " proposed to create instance");
    }
}

In thread safe code we can see that we are using synchronized keyword which will be used to synchronize threads. If multiple threads try to access the instance of class, the first will acquire synchronized and will proceed next, while the rest will wait until the first thread finishes its execution in that class. And again when second thread, third thread so on move one by one synchronously and as first thread already created instance, the rest of the threads will use the same instance for further execution.

 

To test the above threadsafe singleton code we will ceate a sample thread class and we will use it  in main class. Below is the sample class which extends Thread class 

package com.sdp;

public class Sample extends  Thread {

    private String praposal;

    public Sample(String Praposal){

        praposal = Praposal;
    }
    public void run()
    {
        try
        {
            ThreadSafeSingleton threadSafeSingleton = ThreadSafeSingleton.getInstance(praposal);
            threadSafeSingleton.printPraposalName();
        }
        catch (Exception e)
        {
            System.out.println ("Exception is caught");
        }
    }
}

Below is code where we are creating multiple instances in 4 different threads and while creating each instance we are passing thread name. As per above, the explanation class should maintain the proposal of the first thread. 

package com.sdp;

public class Main {

    public static void main(String[] args) {

        Thread threadA=new Sample("threadA");
        Thread threadB=new Sample("threadB");
        Thread threadC=new Sample("threadC");
        Thread threadD=new Sample("threadD");

        threadA.run();
        threadB.run();
        threadC.run();
        threadD.run();
    }
}

Below is the output of Thread Safe Singleton accessing code. In the below output we can see that threadA hit the Thread Safe Singleton code and created instance and the other 3 threads; i.e. thread, threadC, threadD access same instance created by threadA

 

 

Summary

 

In this article we learned how to create singleton instance and where to use it. And also we saw how to implement thread safe singleton instance.