Profile Photo

Singleton design pattern

Created on: Jan 19, 2025

Singleton design pattern is a creation design pattern where class is restricted to have only one instance in the java virtual machine.

There are two ways we can instantiate Singleton design pattern.

  1. Early instantiation
  2. Lazy Instantiation

Early instantiation

class Singleton{

    private static volatile Singleton singleton = new Singleton();

    private Singleton(){};

    public static Singleton getInstance(){
        return singleton;
    }
}

There are some Drawback of above implementation.

  1. Instance is created even when not required.
  2. It can cause memory leak problem

Lazy Instantiation:

class Singleton {

    private static Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

Singleton nature in above can be broken down in multiple ways.

  1. Multi Threading
  2. Reflection api
  3. Serialization
  4. Cloning

Let's check one by one and try to resolve those.

1. Multi Threading

if multiple thread is accessing getInstance at same time, it can create multiple instances. Below is same example

package com.learning.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Singleton {

    private static Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            try{
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
            singleton = new Singleton();
        }
        return singleton;
    }
}

public class Solution {

    public static void main(String[] args) {

        Runnable task = () -> {
            Singleton singleton = Singleton.getInstance();
            System.out.println(singleton.hashCode());
        };

        ExecutorService executorService = Executors.newFixedThreadPool(5);

        int iterateCount = 5;
        while (iterateCount-- > 0) {
            executorService.submit(task);
            executorService.submit(task);
        }
        executorService.shutdown();
    }
}
938463199
1909241014
1229394636
1909241014
1909241014
1909241014
1909241014
1909241014
1338996218
1221641224

You can see multiple instances as multiple hashcode are coming. Let's solve this problem by adding the logic for creating instance in synchrnonised block. Also we will adding volatile modifier which will ensure that changes made to the singleton instance by one thread are visible to all thread.

class Singleton {
    private static volatile Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            try{
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
            synchronized(Singleton.class){ // // making this thread safe
                if(singleton==null){ // if there is no instance available... create new one
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

2. Reflection api

Java reflection api can change constructor accessibility and create instance. Let's break singleton nature using reflection api.

import java.lang.reflect.Constructor;

class Singleton {
     private static volatile Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized(Singleton.class){
                if(singleton==null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
public class Solution {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();

        Singleton singleton2 = null;
        try{
            Class<Singleton> singletonClass = Singleton.class;
            Constructor<Singleton> singletonConstructor = singletonClass.getDeclaredConstructor();
            singletonConstructor.setAccessible(true);
            singleton2 = singletonConstructor.newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("hascode 1 "+ singleton.hashCode());
        System.out.println("hascode 2 "+ singleton2.hashCode());
    }
}
hascode 1 764977973
hascode 2 1915910607

To solve this problem, we can add restriction in contructor. If a instance is not null, it will throw exception.


import java.lang.reflect.Constructor;

class Singleton {
    private static volatile Singleton singleton;

    private Singleton() {
        if (singleton != null)
            throw new RuntimeException("Only single instance can be created");
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized(Singleton.class){
                if(singleton==null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

public class Solution {

    public static void main(String[] args) {

        Singleton singleton = Singleton.getInstance();

        Singleton singleton2 = null;
        try{
            Class<Singleton> singletonClass = Singleton.class;
            Constructor<Singleton> singletonConstructor = singletonClass.getDeclaredConstructor();
            singletonConstructor.setAccessible(true);
            singleton2 = singletonConstructor.newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("hascode 1 "+ singleton.hashCode());
        System.out.println("hascode 2 "+ singleton2.hashCode());
    }
}
ava.lang.reflect.InvocationTargetException
	at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at java.base/jdk.internal.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.base/java.lang.reflect.Constructor.newInstance(Constructor.java:490)
	at com.learning.test.Solution.main(Solution.java:38)
Caused by: java.lang.RuntimeException: Only single instance can be created
	at com.learning.test.Singleton.<init>(Solution.java:12)
	... 5 more
hascode 1 2083562754
Exception in thread "main" java.lang.NullPointerException
	at com.learning.test.Solution.main(Solution.java:43)

3. Serialization

Still our Singleton class nature can be brake by exporting object into byte stream and again importing it. Below is the code to illustrate it.


import java.io.*;

class Singleton implements Serializable{
    private static volatile Singleton singleton;

    private Singleton() {
        if (singleton != null)
            throw new RuntimeException("Only single instance can be created");
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized(Singleton.class){
                if(singleton==null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

public class Solution {

    public static void main(String[] args) {

        try {
            Singleton singleton = Singleton.getInstance();
            ObjectOutput objectOutput = null;

            objectOutput = new ObjectOutputStream(new FileOutputStream("out.ser"));
            objectOutput.writeObject(singleton);
            objectOutput.close();

            ObjectInput in = new ObjectInputStream(new FileInputStream("out.ser"));
            Singleton singleton2 = (Singleton) in.readObject();
            in.close();

            System.out.println("instance1 hashCode=" + singleton.hashCode());
            System.out.println("instance2 hashCode=" + singleton2.hashCode());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
instance1 hashCode=356473385
instance2 hashCode=1364614850

We can solve above problem by adding readResolve method. It's a special method that the serialization framework looks for at runtime. If it is not present, object is created using the no-argument constructor.

class Singleton implements Serializable{
    private static volatile Singleton singleton;

    private Singleton() {
        if (singleton != null)
            throw new RuntimeException("Only single instance can be created");
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized(Singleton.class){
                if(singleton==null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    protected Object readResolve(){ // prevents serialisation effect
        return getInstance();
    }
}

public class Solution {

    public static void main(String[] args) {

        try {
            Singleton singleton = Singleton.getInstance();
            ObjectOutput objectOutput = null;

            objectOutput = new ObjectOutputStream(new FileOutputStream("out.ser"));
            objectOutput.writeObject(singleton);
            objectOutput.close();

            ObjectInput in = new ObjectInputStream(new FileInputStream("out.ser"));
            Singleton singleton2 = (Singleton) in.readObject();
            in.close();

            System.out.println("instance1 hashCode=" + singleton.hashCode());
            System.out.println("instance2 hashCode=" + singleton2.hashCode());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

instance1 hashCode=356473385
instance2 hashCode=356473385

4. Cloning

Cloning can also break singleton nature. Below is code to illustrate above.

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class Singleton implements Serializable, Cloneable {
    private static volatile Singleton singleton;

    private Singleton() {
        if (singleton != null)
            throw new RuntimeException("Only single instance can be created");
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    protected Object readResolve() { // prevents serialisation effect
        return getInstance();
    }
}

public class Solution {
    public static void main(String[] args) throws NoSuchMethodException,
            IllegalAccessException, InvocationTargetException {

        Singleton singleton = Singleton.getInstance();

        Method cloneMethod = Object.class.getDeclaredMethod("clone");
        cloneMethod.setAccessible(true);

        Singleton singleton2 = (Singleton) cloneMethod.invoke(singleton);

        System.out.println("Instance 1 hashcode: " + singleton.hashCode());
        System.out.println("Instance 2 hashcode: " + singleton2.hashCode());
    }
}
Instance 1 hashcode: 1308927845
Instance 2 hashcode: 331844619

Let's fix above program by overriding clone method.


import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class Singleton implements Serializable, Cloneable {
    private static volatile Singleton singleton;

    private Singleton() {
        if (singleton != null)
            throw new RuntimeException("Only single instance can be created");
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    protected Object readResolve() { // prevents serialisation effect
        return getInstance();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException{
        throw new CloneNotSupportedException("Singleton cloning not allowed");
    }
}

public class Solution {
    public static void main(String[] args) throws NoSuchMethodException,
            IllegalAccessException, InvocationTargetException {

        Singleton singleton = Singleton.getInstance();

        Method cloneMethod = Object.class.getDeclaredMethod("clone");
        cloneMethod.setAccessible(true);

        Singleton singleton2 = (Singleton) cloneMethod.invoke(singleton);

        System.out.println("Instance 1 hashcode: " + singleton.hashCode());
        System.out.println("Instance 2 hashcode: " + singleton2.hashCode());
    }
}
Exception in thread "main" java.lang.reflect.InvocationTargetException
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.base/java.lang.reflect.Method.invoke(Method.java:566)
	at com.learning.test.Solution.main(Solution.java:45)
Caused by: java.lang.CloneNotSupportedException: Singleton cloning not allowed
	at com.learning.test.Singleton.clone(Solution.java:32)
	... 5 more

You can see that program is throwing exception when we try to clone and create new instance.

Below are some use case of Singleton design pattern

  1. Database connections are resource-intensive and should be managed carefully. A Singleton can ensure only one connection pool is created for the entire application.
  2. Applications often have a global configuration (e.g., API keys, file paths, environment settings) that needs to be shared across the app. Using a Singleton ensures all components access the same configuration settings.
  3. Cache Management: In large-scale applications, caching data improves performance by avoiding repetitive computations or database queries. A Singleton cache ensures there’s only one cache instance, reducing memory usage and preventing inconsistent data.
  4. Load Balancer: In distributed systems, a load balancer distributes incoming requests to multiple servers. A Singleton load balancer ensures a consistent strategy and state in balancing loads.