What is the need for Singleton Pattern ?
Let's say we need to connect to DB and for every request if we keep creating a new Instance of Db connection to connect to Db this will create a Performance overhead. As it is costly to create a Db connection for every request and it takes time to create the connection which causes delay.
How can we solve this ?
If we keep one connection and use it everytime connecting to DB for every request then while one request is using the connection other requests need to wait. to solve this we need to create a DB connection pool
properties that db connection pool need to satisfy :
- it should be a single Instance. Multiple instance creation should not be allowed
- single source of truth
How can we design a Singleton pattern ?
package singleton_db_connection;
public class Client {
public static void main(String[] args){
Dbc dbc1 = new Dbc();
Dbc dbc2 = new Dbc();
System.out.println(dbc1);
System.out.println(dbc2);
}
}
package singleton_db_connection;
public class Dbc {
public Dbc(){
}
}
in the code we can see if we are able to create a instance of the Class then every time it will change so we shouldnot allow user to create multiple instances. so lets make the constructor private.
public class Dbc {
private Dbc(){
}
}
Now we cannot create single instance. we need a single Instance so lets create a Static data member and method
package singleton_db_connection;
public class Client {
public static void main(String[] args){
System.out.println(Dbc.getInstance());
System.out.println(Dbc.getInstance());
}
}
package singleton_db_connection;
public class Dbc {
private static Dbc INSTANCE;
private Dbc(){
}
public static Dbc getInstance(){
if(INSTANCE == null){
INSTANCE = new Dbc();
}
return INSTANCE;
}
}
Now if we run this every time we get the same Instance of Db connection. But wait will this work if we try to access getInstance concurrently
package singleton_db_connection;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class Client {
public static void main(String[] args) throws InterruptedException {
Runnable task = () -> {
System.out.println(Thread.currentThread().getName() + " " + Dbc.getInstance());
};
ExecutorService ex = Executors.newFixedThreadPool(5);
for(int i = 0; i < 100; i++){
ex.submit(task);
}
ex.shutdown();
ex.awaitTermination(1 , TimeUnit.MINUTES);
}
}
package singleton_db_connection;
public class Dbc {
private static Dbc INSTANCE;
private Dbc(){
}
public static Dbc getInstance(){
if(INSTANCE == null){
INSTANCE = new Dbc();
}
return INSTANCE;
}
}
this fails as multiple threads try to access the getInstance method at once and multiple instances of Dbc can get created
How about if we make this synchronized ?
public synchronized static Dbc getInstance(){
if(INSTANCE == null){
INSTANCE = new Dbc();
}
return INSTANCE;
}
if we make it synchronized then at a time only one request can access it then it is like having only one db connection instead of multiple connections at once one thread get's access it will lock and other's need to wait till it gets unlocked
can we make use of class loading ?
what is class loading ?
before running the main method the JVM checks if there are any static variables and assigns them to class
package singleton_db_connection;
public class Dbc {
private static final Dbc INSTANCE = new Dbc(); // we made it final so only one time it gets assigned value
private Dbc(){
}
public static Dbc getInstance(){
return INSTANCE; // returns the same instance
}
}
what are the issues with class loading ?
class loading uses eager loading. So if there are more static variables that needs to be assigned to class the initial loading time will be more.
if we initialize the INSTANCE using class loading but no other class is using the INSTANCE then the resource will be wasted
What if we use the lock inside if condition ?
package singleton_db_connection;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Dbc {
private static Dbc INSTANCE;
private Dbc(){
}
private static Lock lock = new ReentrantLock();
public static Dbc getInstance(){
if(INSTANCE == null){
lock.lock();
INSTANCE = new Dbc();
lock.unlock();
}
return INSTANCE;
}
}
At start when INSTANCE is null and multiple threads access the getInstance method and they all enter inside if condition , they will create multiple instances of the Dbc class. How can we solve this ?
we need to another if condition inside the lock and only then we allow the create new Dbc instance
public static Dbc getInstance(){
if(INSTANCE == null){
lock.lock();
if(INSTANCE == null) {
INSTANCE = new Dbc();
}
lock.unlock();
}
return INSTANCE;
}
inside the lock only one thread can go and it will check again if INSTANCE is null only if it is not null then it will create a new Instance
And this is how a singleton design pattern works
If you found this helpful or have suggestions, drop a comment below! I'm writing notes as I learn design patterns and would love feedback.