Singelton pattern restricts the instantiation of a class and ensures that only one instance of the class exists per JVM.
To implement Singleton pattern, we have to follow the following step.
1. Constructor should be private.
2. Public static method that returns the instance of the class.
Lazy Initialization:
When you call the getInstance method then the object of the singleton class is created.
public class SingletonPattern {
private static SingletonPattern instance;
private SingletonPattern() {
}
public
static SingletonPattern getInstance() {
if (instance == null) {
instance = new SingletonPattern();
}
return instance;
}
}
Thread-Safe Singleton:
In the case of thread safe singleton, we use the synchronized block or synchronized method to create the thread safe singleton class.
Below example is also known as double check locking. In this approach ,the synchronized block is used inside the if condition with an additional check to ensure that only one instance of singleton class is created.
public class ThreadSafeSingleton {
private
volatile ThreadSafeSingleton instance;
private ThreadSafeSingleton(){}
public static ThreadSafeSingleton getInstanceUsingDoubleLocking(){
if(instance == null){
synchronized (ThreadSafeSingleton.class) {
if(instance == null){
instance = new ThreadSafeSingleton();
}
}
}
return instance;
}
}
Bill Pugh Singleton Implementation:
In this approach when the singleton class is loaded, SingletonHelper class is not loaded into memory and only when someone calls the getInstance method, this class get loaded and create the singleton class instance.
public class Logger {
private Logger(){}
private static class SingletonHelper{
private static final Logger INSTANCE = new Logger();
}
public static Logger getInstance(){
return SingletonHelper.INSTANCE;
}
}
Note: Above approach doesn't require Synchronization.
Enum Singleton:
When we use the reflection then above all approach break and we are able to create more than one object of each Singleton class to overcome this challenge we are using the enum singleton class.
public enum EnumSingleton {
INSTANCE;
}
Note:Only drawback of above approach is that it is not supporting the lazy loading.
