JournalDev

Java, Java EE, Android, Python, Web Development Tutorials

You are here: Home » Java » Design Patterns » Java Singleton Design Pattern Best Practices with Examples

Java Singleton Design Pattern Best Practices with Examples

215 Comments

Java Singleton Pattern is one of the Gangs of Four Design patterns and comes in the Creational Design Pattern category. From the definition, it seems to be a very simple design pattern but when it comes to implementation, it comes with a lot of implementation concerns. The implementation of Java Singleton pattern has always been a controversial topic among developers. Here we will learn about Singleton design pattern principles, different ways to implement the Singleton design pattern and some of the best practices for its usage.

Java Singleton

  • Singleton pattern restricts the instantiation of a class and ensures that only one instance of the class exists in the java virtual machine.
  • The singleton class must provide a global access point to get the instance of the class.
  • Singleton pattern is used for logging, drivers objects, caching and thread pool.
  • Singleton design pattern is also used in other design patterns like Abstract Factory, Builder, Prototype, Facade etc.
  • Singleton design pattern is used in core java classes also, for example java.lang.Runtime, java.awt.Desktop.

java singleton pattern, singleton class in java

Java Singleton Pattern

To implement a Singleton pattern, we have different approaches but all of them have the following common concepts.

  • Private constructor to restrict instantiation of the class from other classes.
  • Private static variable of the same class that is the only instance of the class.
  • Public static method that returns the instance of the class, this is the global access point for outer world to get the instance of the singleton class.

In further sections, we will learn different approaches of Singleton pattern implementation and design concerns with the implementation.

  1. Eager initialization
  2. Static block initialization
  3. Lazy Initialization
  4. Thread Safe Singleton
  5. Bill Pugh Singleton Implementation
  6. Using Reflection to destroy Singleton Pattern
  7. Enum Singleton
  8. Serialization and Singleton

Eager initialization

In eager initialization, the instance of Singleton Class is created at the time of class loading, this is the easiest method to create a singleton class but it has a drawback that instance is created even though client application might not be using it.

Here is the implementation of the static initialization singleton class.

Copy

package com.journaldev.singleton;

public class EagerInitializedSingleton {
    
    private static final EagerInitializedSingleton instance = new EagerInitializedSingleton();
    
    //private constructor to avoid client applications to use constructor
    private EagerInitializedSingleton(){}

    public static EagerInitializedSingleton getInstance(){
        return instance;
    }
}

If your singleton class is not using a lot of resources, this is the approach to use. But in most of the scenarios, Singleton classes are created for resources such as File System, Database connections etc. We should avoid the instantiation until unless client calls the getInstance method. Also, this method doesn’t provide any options for exception handling.

Static block initialization

Static block initialization implementation is similar to eager initialization, except that instance of class is created in the static block that provides option for exception handling.

Copy

package com.journaldev.singleton;

public class StaticBlockSingleton {

    private static StaticBlockSingleton instance;
    
    private StaticBlockSingleton(){}
    
    //static block initialization for exception handling
    static{
        try{
            instance = new StaticBlockSingleton();
        }catch(Exception e){
            throw new RuntimeException("Exception occured in creating singleton instance");
        }
    }
    
    public static StaticBlockSingleton getInstance(){
        return instance;
    }
}

Both eager initialization and static block initialization creates the instance even before it’s being used and that is not the best practice to use. So in further sections, we will learn how to create a Singleton class that supports lazy initialization.

Read: Java static

Lazy Initialization

Lazy initialization method to implement Singleton pattern creates the instance in the global access method. Here is the sample code for creating Singleton class with this approach.

Copy

package com.journaldev.singleton;

public class LazyInitializedSingleton {

    private static LazyInitializedSingleton instance;
    
    private LazyInitializedSingleton(){}
    
    public static LazyInitializedSingleton getInstance(){
        if(instance == null){
            instance = new LazyInitializedSingleton();
        }
        return instance;
    }
}

The above implementation works fine in case of the single-threaded environment but when it comes to multithreaded systems, it can cause issues if multiple threads are inside the if condition at the same time. It will destroy the singleton pattern and both threads will get the different instances of the singleton class. In next section, we will see different ways to create a thread-safe singleton class.

Thread Safe Singleton

The easier way to create a thread-safe singleton class is to make the global access method synchronized, so that only one thread can execute this method at a time. General implementation of this approach is like the below class.

Copy

package com.journaldev.singleton;

public class ThreadSafeSingleton {

    private static ThreadSafeSingleton instance;
    
    private ThreadSafeSingleton(){}
    
    public static synchronized ThreadSafeSingleton getInstance(){
        if(instance == null){
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
    
}

Above implementation works fine and provides thread-safety but it reduces the performance because of the cost associated with the synchronized method, although we need it only for the first few threads who might create the separate instances (Read: Java Synchronization). To avoid this extra overhead every time, double checked locking principle is used. In this approach, the synchronized block is used inside the if condition with an additional check to ensure that only one instance of a singleton class is created.

Below code snippet provides the double-checked locking implementation.

Copy

public static ThreadSafeSingleton getInstanceUsingDoubleLocking(){
    if(instance == null){
        synchronized (ThreadSafeSingleton.class) {
            if(instance == null){
                instance = new ThreadSafeSingleton();
            }
        }
    }
    return instance;
}

Read: Thread Safe Singleton Class

Bill Pugh Singleton Implementation

Prior to Java 5, java memory model had a lot of issues and the above approaches used to fail in certain scenarios where too many threads try to get the instance of the Singleton class simultaneously. So Bill Pugh came up with a different approach to create the Singleton class using an inner static helper class. The Bill Pugh Singleton implementation goes like this;

Copy

package com.journaldev.singleton;

public class BillPughSingleton {

    private BillPughSingleton(){}
    
    private static class SingletonHelper{
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }
    
    public static BillPughSingleton getInstance(){
        return SingletonHelper.INSTANCE;
    }
}

Notice the private inner static class that contains the instance of the singleton class. When the singleton class is loaded, SingletonHelper class is not loaded into memory and only when someone calls the getInstance method, this class gets loaded and creates the Singleton class instance.

This is the most widely used approach for Singleton class as it doesn’t require synchronization. I am using this approach in many of my projects and it’s easy to understand and implement also.

Read: Java Nested Classes

Using Reflection to destroy Singleton Pattern

Reflection can be used to destroy all the above singleton implementation approaches. Let’s see this with an example class.

Copy

package com.journaldev.singleton;

import java.lang.reflect.Constructor;

public class ReflectionSingletonTest {

    public static void main(String[] args) {
        EagerInitializedSingleton instanceOne = EagerInitializedSingleton.getInstance();
        EagerInitializedSingleton instanceTwo = null;
        try {
            Constructor[] constructors = EagerInitializedSingleton.class.getDeclaredConstructors();
            for (Constructor constructor : constructors) {
                //Below code will destroy the singleton pattern
                constructor.setAccessible(true);
                instanceTwo = (EagerInitializedSingleton) constructor.newInstance();
                break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(instanceOne.hashCode());
        System.out.println(instanceTwo.hashCode());
    }

}

When you run the above test class, you will notice that hashCode of both the instances is not same that destroys the singleton pattern. Reflection is very powerful and used in a lot of frameworks like Spring and Hibernate, do check out Java Reflection Tutorial.

Enum Singleton

To overcome this situation with Reflection, Joshua Bloch suggests the use of Enum to implement Singleton design pattern as Java ensures that any enum value is instantiated only once in a Java program. Since Java Enum values are globally accessible, so is the singleton. The drawback is that the enum type is somewhat inflexible; for example, it does not allow lazy initialization.

Copy

package com.journaldev.singleton;

public enum EnumSingleton {

    INSTANCE;
    
    public static void doSomething(){
        //do something
    }
}

Read: Java Enum

Serialization and Singleton

Sometimes in distributed systems, we need to implement Serializable interface in Singleton class so that we can store its state in the file system and retrieve it at a later point of time. Here is a small singleton class that implements Serializable interface also.

Copy

package com.journaldev.singleton;

import java.io.Serializable;

public class SerializedSingleton implements Serializable{

    private static final long serialVersionUID = -7604766932017737115L;

    private SerializedSingleton(){}
    
    private static class SingletonHelper{
        private static final SerializedSingleton instance = new SerializedSingleton();
    }
    
    public static SerializedSingleton getInstance(){
        return SingletonHelper.instance;
    }
    
}

The problem with serialized singleton class is that whenever we deserialize it, it will create a new instance of the class. Let’s see it with a simple program.

Copy

package com.journaldev.singleton;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class SingletonSerializedTest {

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        SerializedSingleton instanceOne = SerializedSingleton.getInstance();
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                "filename.ser"));
        out.writeObject(instanceOne);
        out.close();
        
        //deserailize from file to object
        ObjectInput in = new ObjectInputStream(new FileInputStream(
                "filename.ser"));
        SerializedSingleton instanceTwo = (SerializedSingleton) in.readObject();
        in.close();
        
        System.out.println("instanceOne hashCode="+instanceOne.hashCode());
        System.out.println("instanceTwo hashCode="+instanceTwo.hashCode());
        
    }

}

The output of the above program is;

Copy

instanceOne hashCode=2011117821
instanceTwo hashCode=109647522

So it destroys the singleton pattern, to overcome this scenario all we need to do it provide the implementation of readResolve() method.

Copy

protected Object readResolve() {
    return getInstance();
}

After this, you will notice that hashCode of both the instances is same in the test program.

Read: Java Serialization and Java Deserialization.

I hope this article helps you in grasping fine details of Singleton design pattern, do let me know through your thoughts and comments.

WhatsAppRedditLinkedin

Comments

  1. Hi Pankaj,

    I follow your articles.

    I think the below code is thread safe as the object will be created only once.

    package com.journaldev.singleton;

    public class EagerInitializedSingleton {

    private static final EagerInitializedSingleton instance = new EagerInitializedSingleton();

    //private constructor to avoid client applications to use constructor
    private EagerInitializedSingleton(){}

    public static EagerInitializedSingleton getInstance(){
    return instance;
    }
    }

    Please clarify?

    Thanks
    Naidu

    Reply

  2. Which approach is preferred? DCC with volatile instance of singleton

    OR

    static inner helper class

    Noticed the volatile instance case isn’t mentioned here

    Reply

  3. I recommend capitalizing “instance” in the eager initialization example, as it follows convention, but also drives home the point of the instance being final and created at class load.

    Reply

  5. why we declare it as static “private static StaticBlockSingleton instance”
    what would go wrong if we declare it as non static

    Reply

    • You must consider a multithreaded behaviour in order to obtain exact single(ton) instance. In Multithreaded environment, the instance created with static will ensure to have same thread stack irrespective of multiple thread instances created.

      Reply

  6. For Eager initialization methods, I do not think that there will be the mentioned issue if there are no other non-private static methods (or static fields) of the Singleton class other than getInstance method. As any class is only loaded when its constructor is called or any static method or field is accessed or it is loaded / instantiated using Reflection API, so our class will load only when getInstance is called. In most scenarios, Reflection is not used, so implementing eager initialization method should be an easy way to simulate Singleton pattern for most use cases.

    Reply

  7. Please clarify me why we cannot use exception handling in your eager Initialization example (very first case)

    Reply

    • @Mayank try block can only be used for statements from method body or static initializer. We can not use it for variable declaration.

      Reply

  8. Hi Pankaj,

    Thanks a lot for such a wonderful explanation.
    Please clarify me that why we cannot write exception handling code (try-catch()) in the example given by you in eager initialization case (the very first case) to create singleton class.

    Reply

  9. your code about thread-safe singleton is wrong.
    miss volatile

    however, the link you given is correct.

    please update your post.

    Reply

  11. package com.singleton;

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInput;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutput;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;

    class Demo1 implements Serializable {

    /**
    *
    */
    private static final long serialVersionUID = 1L;

    private static Demo1 obj = null;

    private Demo1() {

    }

    protected Object readResolve() {
    System.out.println(“read reslove called”);
    return getInstance();
    }

    // if making synchronized then one thread will execute it at one time…//if
    // performance of get instance
    public static Demo1 getInstance() {
    if (obj == null) {
    System.out.println(“obj null”);
    return new Demo1();
    } else
    return obj;
    }
    }

    public class Demo {

    public static void main(String args[]) throws FileNotFoundException, IOException, ClassNotFoundException {
    Demo1 obj = Demo1.getInstance();
    ObjectOutput out = new ObjectOutputStream(new FileOutputStream(“abc.ser”));
    out.writeObject(obj);
    out.close();
    ObjectInput in = new ObjectInputStream(new FileInputStream(“abc.ser”));
    Demo1 obj1 = (Demo1) in.readObject();
    System.out.println(obj.hashCode());
    System.out.println(obj1.hashCode());

    }

    }
    output :obj null
    read reslove called
    obj null
    26253138
    8860464
    why hashcode different as i did readReslove()called

    Reply

    • You implemented static factory method instead of a singleton pattern. Above getInstance method returns a new Singular object after every invocation, hence different hashcodes.

      Replace with below snippet and thread unsafe singleton class is ready.

      public static Singular getInstance() {
      if (obj == null) {
      System.out.println(“obj null”);
      return obj=new Singular();
      } else
      return obj;
      }

      Reply

  15. Thank you so much for giving this kind of article for helping us a lot. Its very useful and helpful to understand various type to create the singleton classes.

    Reply

  16. Nice one!!
    But you didn’t cover about cloning the singleton.
    To avoid it you must override the clone method as below:

    public Object clone() throws CloneNotSupportedException{
    throw new CloneNotSupportedException(“Singleton, cannot be clonned”);
    }

    Reply

    • import java.util.Scanner;

      public enum EnumSingleton {
      INSTANCE;

      private EnumSingleton(){
      scanner = new Scanner(System.in);
      }

      private Scanner scanner;

      public Scanner getScanner(){
      return scanner;
      }

      }

      Reply

  22. I have use BillPughSingleton implement ion and try to destroy using reflection
    and got exception as
    java.lang.IllegalArgumentException: wrong number of arguments …

    when i check .class file a one arg found
    …
    instanceTwo = (BillPughSingleton)constructor.newInstance(new Object[0]);

    and its accept BillPughSingleton instance

    Reply

    • In the case you can pass the already created instance of Singleton to avoid this Exception to see how reflection test failed for BullPughSingleton solution.

      like below,
      instance2 = (BillPughSingleton) constructor.newInstance(instance);

      Reply

  24. Can we create singleton design pattern which can work in
    multithreaded env and which can not be broken by reflection API ?

    Reply

      • Bu if you throw exception from private constructor it will always throw excpetion and wont allow to create object of that class in any case , even single instance

        Reply

    • Yeah EnumSingleton is perfect approach for it.

      You will get “Class ReflectionEnumSingletonTest can not access a member of class EnumSingleton with modifiers “private”” error message during Reflection test.

      Reply

  25. Based on the number of bytecode instructions, synchronized method would cost less than synchronized block

    ————————————————————————————————————————
    Java code
    ————————————————————————————————————————
    package com.sangchual.java.exercise;

    public class SynchronizedPerforamnce {
    Integer counter = new Integer(0) ;

    public synchronized void runWithSynchronizedMethod() {
    counter ++ ;
    }

    public void runWithSynchronizedBlock() {
    synchronized (this) {
    counter ++ ;
    }
    }
    }

    ————————————————————————————————————————
    Bytecodes
    ————————————————————————————————————————
    ~/w/j/o/p/c/c/s/j/exercise javap -c SynchronizedPerforamnce.class
    Compiled from “SynchronizedPerforamnce.java”
    public class com.sangchual.java.exercise.SynchronizedPerforamnce {
    java.lang.Integer counter;

    public com.sangchual.java.exercise.SynchronizedPerforamnce();
    Code:
    0: aload_0
    1: invokespecial #1 // Method java/lang/Object.””:()V
    4: aload_0
    5: new #2 // class java/lang/Integer
    8: dup
    9: iconst_0
    10: invokespecial #3 // Method java/lang/Integer.””:(I)V
    13: putfield #4 // Field counter:Ljava/lang/Integer;
    16: return

    public synchronized void runWithSynchronizedMethod();
    Code:
    0: aload_0
    1: getfield #4 // Field counter:Ljava/lang/Integer;
    4: astore_1
    5: aload_0
    6: aload_0
    7: getfield #4 // Field counter:Ljava/lang/Integer;
    10: invokevirtual #5 // Method java/lang/Integer.intValue:()I
    13: iconst_1
    14: iadd
    15: invokestatic #6 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
    18: dup_x1
    19: putfield #4 // Field counter:Ljava/lang/Integer;
    22: astore_2
    23: aload_1
    24: pop
    25: return

    public void runWithSynchronizedBlock();
    Code:
    0: aload_0
    1: dup
    2: astore_1
    3: monitorenter
    4: aload_0
    5: getfield #4 // Field counter:Ljava/lang/Integer;
    8: astore_2
    9: aload_0
    10: aload_0
    11: getfield #4 // Field counter:Ljava/lang/Integer;
    14: invokevirtual #5 // Method java/lang/Integer.intValue:()I
    17: iconst_1
    18: iadd
    19: invokestatic #6 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
    22: dup_x1
    23: putfield #4 // Field counter:Ljava/lang/Integer;
    26: astore_3
    27: aload_2
    28: pop
    29: aload_1
    30: monitorexit
    31: goto 41
    34: astore 4
    36: aload_1
    37: monitorexit
    38: aload 4
    40: athrow
    41: return
    Exception table:
    from to target type
    4 31 34 any
    34 38 34 any
    }

    Reply

  26. How are singleton object serialized even if object reference is static?
    According to serialization, static variabal or object are not serialized

    Reply

  27. Very good explanation but I think you missed the concept of cloning, cloning can also break your singleton patten if you class is cloneable. Correct me if I am wrong.

    Reply

  28. Hi Pankaj,

    I have a doubt in your Bill paugh Singleton implementation. You have stated that static nested class is not loaded into memory during class loading . But i have studied as static stuffs are always loaded with class initialization in JAVA. and they share with every class instance. Since in Bill paugh implemetation it is loaded only when we call getInstance method why ?

    Reply

    • The classloader doesnot differentiate whether its a inner class or not.
      Our concern here is when its initialized irrespective of when its loaded.
      It is initialised when it is needed inside the getInstance().

      Reply

      • INSTANCE will be creating on class loading?? I m confused about this.Please clear ..as per my understanding instance should be instantiated on class loading

        Reply

  32. Hi Pankaj,

    Your way of explanation with examples is awesome.

    Can you provide the example for “Enum Singleton”.

    Thanks,
    Murali

    Reply

    • Based on Pankaj’s Enum singleton above, you would call “doSomething()” like this:

      package your.package.name;
      import com.journaldev.singleton.EnumSingleton;
      public class Client {
      public static void main(String[] args) {
      EnumSingleton.INSTANCE.doSomething(); // OR use class variable like below…
      }
      }

      package your.package.name;
      import com.journaldev.singleton.EnumSingleton;
      public class Client {
      private final EnumSingleton INST = EnumSingleton.INSTANCE;
      public static void main(String[] args) {
      INST.doSomething();
      }
      }

      For the Enum Singleton, as it is an Enum type – you can implement but NOT extend classes, so consider that when choosing between what design to use for your Singletons.

      Reply

  40. Hi,
    I have written the simple program like below. It is not throwing any error even though I am creating object again in main method. Please let me know if we are able to create object again in main method what is the use of singleton.
    package com.java.designpatterns;

    public class SingletonPattern {

    private static final SingletonPattern singletonPattern = new SingletonPattern();

    private SingletonPattern(){}

    public static SingletonPattern getInstance(){
    return singletonPattern;
    }

    public static void main(String[] args) {
    // TODO Auto-generated method stub
    SingletonPattern singletonPattern = new SingletonPattern();
    singletonPattern.getInstance();
    System.out.println(“Hi”);
    }

    }

    Reply

    • Dear Sasi,

      You are creating the object of SingletonPattern in the same class hence you can access the private constructor which you have created in the same class. You should create a new test class to test whether it is allowing you to create a new object for SingletonPattern.

      Try This,

      class SingletonPattern {

      private static final SingletonPattern singletonPattern = new SingletonPattern();

      private SingletonPattern(){}

      public static SingletonPattern getInstance(){
      return singletonPattern;
      }

      }

      Test class:

      class Test
      {

      SingletonPattern singletonPattern = new SingletonPattern();// Error, since the constructor is private
      singletonPattern.getInstance();
      System.out.println(“Hi”);
      }

      Reply

  41. Gotcha with method :
    public Object readResolve()
    {
    return getInstance();
    }

    Only works in Single main thread. if you write serialized Singleton object in first program. In second program if you deserialize and try to readObject() then to get Singleton Object, But it will give you NULL object.

    So this method won’t work across program or jvm

    Reply

  44. Initially i was surprise with the number of comments.
    but could not stop myself to write this comment, It is really good article for singleton design pattern.

    Reply

    • its Awesome explanation . it will be good if u add more lectures on
      protected Object readResolve() {
      return getInstance();
      }

      Reply

  45. The following code doesn’t work, please help, thanks!
    ———————————————————————————————————–
    public class SerializedSingleton implements Serializable{

    private static final long serialVersionUID = -7604766932017737115L;

    private SerializedSingleton(){}

    private static class SingletonHelper{
    private static final SerializedSingleton instance = new SerializedSingleton();
    }

    public static SerializedSingleton getInstance(){
    return SingletonHelper.instance;
    }

    protected Object readResolve() {
    return getInstance();
    }
    }
    ——————————————————————————————————-
    Thanks!

    Reply

  49. Bill Pugh Singleton Implementation, how it will resolve the double locking issue? if two threads accessing it first time ?

    Reply

  51. Hi Guys,

    How to use singleton in serialization…? & Which method we can use for singleton…?
    Thanks,
    Kirubakaran

    Reply

    • It is because SingletonHelper class will be loaded only when we refer
      SingletonHelper.instance;
      and as class loading is thread-safe, static members initialization also happens only once and hence only one object is created though multiple threads call at the same time.

      Since classsloader initializing the member, it is thread safe.

      Reply

    • Hi Vishwas,

      If we are not implement singleton class with Cloneable interface then no one can create a clone object of the Singleton class.
      If anyone trying to do clone() then it will throw CloneNotSupportedException.

      Reply

  56. Hi Pankaj,
    We can restrict the object creation by using Reflection by putting below piece of code in Constructor.

    if(SingletonHelper.INSTANCE != null){
    throw new RuntimeException(“Singleton already initialized”);
    }

    Or
    if(!Thread.currentThread().getStackTrace()[2].getClassName().equals(“BillPughSingleton”)){
    throw new RuntimeException(“Singleton already initialized”);
    }

    Can you please confirm Is this a correct approach to make a class singleton?

    Reply

    • This is not a singleton. Because it will not return same object instead it throws exception. But that is not what singleton implementation.

      Reply

  57. I have written the singleton with the use of AtomicReference, for first few thread create multiple instance but getInstance() always return single object. For some senario we can use this also, there is no synchronization used.

    import java.util.concurrent.atomic.AtomicReference;

    public class SingleTon {

    private static AtomicReference ref = new AtomicReference();

    private SingleTon(){

    }

    public static SingleTon getInstance(){
    SingleTon singleTon = ref.get();
    if(singleTon == null){
    SingleTon singleTon2 = new SingleTon();
    if(ref.compareAndSet(null, singleTon2)){
    return singleTon2;
    }else {
    singleTon = ref.get();
    }
    }
    return singleTon;
    }

    public void test(){
    System.out.println(“SingleTon.test()*******”);
    }
    }

    Reply

    • It’s almost similar to double locking singleton method. There also synchronized is inside the if null check, so it will be used only once.

      Reply

  58. Reference variable of any singleton object would be Static type and as per my knowledge we can not serialize Static object. My question is how are we serializing an Static object??

    Reply

  59. Hi Pankaj,

    Very nice article, covers all of the scenarios and approaches for creating Singleton object.

    Thanks!

    Reply

  61. Pankaj,
    Very informative article.
    I think all the drawback of singleton can be eliminated by using ENUM ie , serialization, synchronization and reflection.

    Reply

  63. I think a pattern made of “Double checked Locking(DCL) with Volatile keyword” exists which has the features of Lazy loading, Multithreading and Singleton . It’s considered better than Bill pugh Singleton Implementation as Bill pugh’s Implementation is considered lazier than lazy Initialization! Please say a word on the difference between Bill pugh Implementation and DCL with volatile keyword.

    Reply

  65. When we read your website in mobile then gmail linkdin share option cover the page Content also please we resolve this problem because we due to this we are not able read website content properly.

    Reply

    • can you take a snapshot and email me? the share icons in mobile are stick to the end of screen as horizontal bar and don’t cause any issue while reading article. Can you tell me which mobile you are using, so I can check?

      Reply

  76. It is a very nice post for singleton design pattern with practical example for all the different kind of scenario.
    Thanks Pankaj.

    Reply

  77. Provided explanation is excellent but the same time this code is not covering the clone scenario. It break the code.

    Reply

    • Because in any tyqe of environment at any instance of time only one thread will make the call to getInstance() method and if it is not the very first call ( which will load the inner class and therefore create the INSTANCE first time ) the method returns already loaded same INSTANCE. In bill’s class getInstance() method has only one task – to return the INSTANCE.

      Reply

      • Hi,

        In Bill Pugh implementation, the approach is good, but what he has done is he created the instance as final to make it constant. samething we can do it in eagerly loaded or static initialization or even in synchronised one. what do u say.

        Reply

  79. This is one of the excellent explanation for the Singleton design pattern. Thanks Pankaj for details explanation.

    Reply

  80. Hi Pankaj,
    Awesome article. Minor correction, private constructor was missed in Enum singleton.

    Thanks,
    Rasheed

    Reply

    • There is no need of that. Enum definition. Java 5 onwards– Only one instance will be there like in the above examle the instance named as INSTANCE. you can use any other name e.g.

      public enum EnumSingleton {

      ONLYTHIS;

      public static void doSomething(){
      //do something
      }
      }

      Reply

  83. All the approached greatly explained along with concern issues and benefits. Awesome article. Pankaj I personally appreciate your understanding. Best ever I had seen a Singleton article. Keep it up!!

    Reply

    • Very Simple. Because if by this time the instance has not been created i.e ==null is true and lets say it is the very first thread executing the code, the thread has the lock (…is inside synchronized block ) it will create the instance. And if this not the very first thread, lets say it is the 2nd thread that now has acquired the lock it won’t create the instance instead it returns the already created one.

      Reply

  85. Very very nice explanation . I would have searched so many blogs but i find the best,this is yours. Thanks a lot.

    Reply

  87. Dear Pankaj,

    I always read your technical blogs, this is awesome explanation with all type of implementation, which really useful in long scale project. thank you so much for writing. keep it up.

    God bless you.

    Thanks,
    Siva

    Reply

  93. public static ThreadSafeSingleton getInstanceUsingDoubleLocking(){
    if(instance == null){
    synchronized (ThreadSafeSingleton.class) {
    if(instance == null){
    instance = new ThreadSafeSingleton();
    }
    }
    }
    return instance;
    }

    This won’t work in case if initializing ThreadSafeSingleton is a heavy process and takes time to initialize.. any other thread may get half initialized object as the first check itself will say that ThreadSafeSingleton != null.
    In a thread safe environment you should get or set the object by acquiring the lock.

    For the rest of the article, it is very good…

    Reply

  98. Hi Pankaj,

    The above article was very good.

    You have covered all the case for the implementation .

    Are you planning to crate a vedio also.

    Wish you a Happy new year and all the best 🙂

    Regards,
    Indrjeet Kumar

    Reply

  99. if (instance == null) {
    synchronized (ThreadSafeSingleton.class) {
    if (instance == null) {
    instance = new ThreadSafeSingleton();
    }
    }
    }

    This double checked locking code won’t work. If you write this code in Netbeans/ Intellij IDEA, it will show warning. Try to avoid this code.

    Reply

  103. Hello Pankaj,

    Like serialization, cloning can also destroy Singleton Pattern? Do you have any example or scenario to prevent object cloning on singleton class ?

    Reply

    • To be able to clone an object it must (or a super class of it) specifically implement Cloneable interface. So generally if you are designing you won’t use Cloneable if you are creating a Singleton. But lets say your singleton is extending from a super class (that is the case some time) and if that super class has a public clone() method, then you should override it and make sure that it throws CloneNotSupportedException.

      Reply

    • I am not sure my answer was good or not, but still I wanted to share my thoughts.
      As multiple clusters involved I hope multiple JVMS will get involved one for each cluster. as there is no way the other JVM know about the object on the other one. so I think it is not possible to achieve what you are thinking.

      Reply

    • Hi Anup,

      you mean, how distributed systems uses only one object? if it is your question, i think we can serialize the object and share those object into distributed systems.

      Reply

  107. Joshua Bloch also suggested , in case of SerializedSingleton we need to make all instance variables transient along with implemention of readResolve() method

    Reply

  110. Thanks for your blog, i have a doubt. actually not clear with, where and how to use below:
    can you please explain with example?

    protected Object readResolve() {
    return getInstance();
    }

    Reply

  112. if i call clone() method on Singleton object was it create new object or return existing one
    if i load a class, using classloaders, is Singleton class has same behavior?
    Could please explain on above….

    Reply

    • try to implement the method with cloneable interface and override clone method by throwing clonenotsupported exception, so that the object will not be cloneable as well.

      Thanks.

      Reply

      • Implement Cloneable interface and Override clone method then return same object like the following:

        class MySingleton implements Serializable,Cloneable{
        private static MySingleton mySing = new MySingleton();
        private MySingleton(){ }

        public static MySingleton getinst(){
        return mySing;
        }
        //Solution for Serialization
        protected Object readResolve() {
        return getinst();
        }

        @Override
        protected Object clone() throws CloneNotSupportedException {

        return getinst();
        }
        }

        Note: It also works for Serilization

        Reply

  115. in Singleton Class implements Serilizable, I added readResolve() method but still serialized object and deserialzed objects hashcodes are different…Please confirm me

    Reply

  118. @Anuj Agarwal
    declaring INSTANCE as a final object restricts re – assignment of a new instance to it.
    final Singleton INSTANCE = new Singleton();
    INSTANCE = new Singleton(); // this won’t work

    Reply

  119. Hi Pankaj,

    Thanks for the elaborate explanations.

    I have a suggestion for you:
    Can you please add a scenario whereby cloning of the Singleton object is explained with an example. It would definitely help to understand different situations where Singleton can be used.

    Best Regards.

    Thanks,
    Nishant Kshirsagar

    Reply

  123. This is the best one stop post for singleton pattern i’ve come across.I had to give a training and this post gave me everything to discuss.
    Thanks a ton Pankaj for your amazing work.

    Reply

  124. Hi Pankaj,

    your articles are very help to build concepts.

    Could you please explain more about this statement of Bill Pugh approach: “This is the most widely used approach for Singleton class as it doesn’t require synchronization.”

    Why this approach doesn’t require synchronization?

    Reply

    • Because when you will call getInstane() method, the class will be loaded first in memory and an instance will get created. So even if multiple threads call getInstance() simultaneously, the class gets loaded only once and you dont need synchronization.

      Reply

      • It means, in Bill Pugh Singleton Implementation approach, we dont need final keyword as used in below:
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();

        It will work fine in all scenarios even if we use it like :
        private static BillPughSingleton INSTANCE = new BillPughSingleton();

        Reply

        • You must declare INSTANCE as final for surety.

          If you don’t then it will allow to change the value of INSTANCE in getInstance () method.
          One can easily change the value for it in your getInstance () method as per below:

          SingletonHelper.INSTANCE = null; // or by any value

          So it is much sure for one to declaring it as final.

          Reply

  131. If you are using an enum as a singleton (only one enum constant “INSTANCE”), it is lazy loaded. If there are multiple enum constants, then they are all created at first access of any constant.

    Reply

  133. Is Reflection breaks Bill Pugh Singleton Implementation?
    I tried it does not create new instance, it throws IllegalArgumentException
    But using serialization it breaks Bill Pugh Singleton Implementation. To avoid this we must use readResolve() method.
    Is it right? if i did mistake please mention it….

    Reply

      • Please look at this below code…… and tell the reason why it’s throwing IllegalArgumentException

        import java.io.Serializable;

        public class Singleton implements Serializable{

        private static final long serialVersionUID = 2L;

        private Singleton(){
        System.out.println(“Singleton”);
        }

        public static Singleton getInstance(){
        return Instance.s;
        }

        private static class Instance{
        private static Singleton s = new Singleton();
        }

        protected Object readResolve(){
        return Instance.s;
        }

        }
        —————————————————————————————————————-
        import java.lang.reflect.Constructor;

        public class Test {

        public static void main(String[] args) throws Exception {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = null;
        try {
        Constructor[] constructors = Singleton.class.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
        constructor.setAccessible(true);
        s2 = (Singleton) constructor.newInstance();
        break;
        }
        } catch (Exception e) {
        e.printStackTrace();
        }
        System.out.println(s1);
        System.out.println(s2);
        }
        }
        ————————————————————————————————————————-
        output:

        Singleton
        java.lang.IllegalArgumentException: wrong number of arguments
        at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
        at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
        at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
        at java.lang.reflect.Constructor.newInstance(Constructor.java:408)
        at com.vel.Test.main(Test.java:14)
        com.vel.Singleton@106d69c
        null
        ——————————————————————————————————————————
        Note : if i remove readResolve() in Singleton class it does not throw any Exception. but I put this method it is throwing IllegalArguementException

        Reply

        • Velmurugan, the method readResolve() works only when the object is read from Stream. This is not the case when you’re using Reflection to destroy the Singleton pattern.

          Reply

          • but I am using readResolve() method, without implements Serializable interface at the time Reflection throws same Exception.
            Is Reflection internally create an Object using Stream? or Internally any concept is going on in readResolve() method?
            Please help me…… to understand

        • Hello, i copy/paste your code in my Eclipse. It works good and no IllegalArgumentException was launched

          Reply

  134. Can you please explain the Singleton enum prevents lazy loading ?I feel that the instance creation happens lazily when it is first accessed.

    Reply

    • Enum variables are static by default, so as soon as you load an Enum all the variable instances will get loaded too. That’s why Enum can’t be used for lazy loading.

      Reply

      • public enum SingletonEnum {
        INSTANCE;
        public static final String Id=”0″;
        private SingletonEnum() {
        System.out.println(“SingletonEnum initialized”);
        }
        public void execute (String arg) {
        // Perform operation here
        }
        }
        class Snippet {
        public static void main(String[] args) {
        System.out.println(SingletonEnum.Id);
        }
        }

        Example to say enum approach is lazy loaded.

        Reply

  135. Hi Pankaj,
    Really nice explanation.
    Could you please let us know the other scinarios also where singleton is not a singleton.
    like, cloning, how distributed systems creates only one object where multiple clusters were involved,
    etc…

    Thanks in advance,….

    Reply

  137. Very nice tutorial.
    It help me lot to understand the singleton.
    Could you please help me how protected Object readResolve() method make i class a singleton.

    Reply

  140. Hi Pankaj,

    Can we create more than one object of a singleton class using serialization ?

    Please provide your view in detail about in which condition Singleton classes can have more than one objects.

    Thanks in advance.

    Regards,
    H Singh

    Reply

    • It depends on the situation, if your singleton is not heavyweight I would prefer pre-initialization but if you want lazy init, then I prefer helper inner class or Enum for singleton.

      Reply

Leave a Reply

Your email address will not be published. Required fields are marked *