Singleton Design pattern with Java

Singleton design pattern belongs to creational design pattern family. Singleton restricts instantiation of a class to one object.

Why singleton?

Share the single instance/ object among the application example:

1)      Connection pool

2)      Service Locator

3)      Configuration properties etc.

Principle: Instance of class is not possible without constructor.

If class does not have any constructor then compiler provides the default public constructor. If class contain at least one constructor at that time complier does not provide default constructor and used the appropriate constructor defined in a class as per the requirement to instantiate object of class.

Note: Define default constructor as private to restrict the initialization of class within same class.

Code Snippet 1:

Delay the instantiation of object until it’s required. The code snippet shows the object is not initialized until Singleton.getInstacne() method called.

package com.ashish.singleton;

public class Singleton

{

    //Declaring singleton field as static field

    //This field has static nature and will shared among all

    //instance of this class.

    private static Singleton singleton=null;

  

    //restrict object creation to this class only

    // Private access modifier play the critical role

    // to restrict the access of the constructor to the outsider.

    private Singleton()

    {

    }

    // Obtain instance of Singleton class with the help of

    // Singleton.getInstance() method.

    public static Singleton getInstance()

    {

        if(singleton ==null)

        {

            singleton=new Singleton();

        }

        return singleton;

    }

   

    // additional stuff ...

}

Restrict the cloning of singleton object by overriding the clone() method of object class

    /*

* Object.clone() is protected methods but it is safe to override and       *restrict the cloning explicitly.

     * Restrict the cloning by overriding clone method of the object class.

     */

    @Override

    protected Object clone() throws CloneNotSupportedException

    {

        throw new CloneNotSupportedException();

    }

Code snippet 2:

Initialize the singleton object as soon as class loader loads the class into the memory.

package com.ashish.singleton;

public  class Singleton

{

    //Singleton instance created by the class loader as soon as class

    // loaded into the memory

    private static Singleton singleton=new Singleton();

  

   

    //restrict object creation to this class only

    // Private access modifier play the critical role

    // to restrict the access of the constructor to the outsider.

    private Singleton()

    {

    }

    // This method just return the instance of class which is created at the

    // class loading time .

    // Singleton.getInstance() method.

    public static Singleton getInstance()

    {

         return singleton;

    }

    /// clone() method ....

    // additional stuff ...

}

Code snippet 3:

Initialize the singleton object as soon as class loader loads the class into the memory.

Code snippet 2 & 3 are identical but code snippet 3 uses static block to instantiate the singleton instance.

package com.ashish.singleton;

public  class Singleton

{

    //Declaring singleton field as static field

    //This field has static nature and will shared among all

    //instance of this class.

    private static Singleton singleton=null;

  

    static

    {

        // initialization of singleton field is handle by the

        // static block

        singleton=new Singleton();

    }

   

    //restrict object creation to this class only

    // Private access modifier play the critical role

    // to restrict the access of the constructor to the outsider.

    private Singleton()

    {

    }

    // Obtain instance of Singleton class with the help of

    // Singleton.getInstance() method.

    public static Singleton getInstance()

    {

         return singleton;

    }

    /// clone() method ....

    // additional stuff ...

}

Singleton design pattern and concurrency issues  

It is advisable to initialize the object only when it’s required. Delay initialization required additional consideration to ensure that integrity of the singleton is maintained even in concurrent access.

Note:  Java used the Monitor concept to implement mutual exclusion among the concurrent thread.

Code snippet 4:

The integrity of singleton object in multi-threaded environment can be sustain by declaring getInstance() as synchronize method.

package com.ashish.singleton;

public  class Singleton

{

    //Declaring singleton field as static field

    //This field has static nature and will shared among all

    //instance of this class.

    private static Singleton singleton=null;

        

    //restrict object creation to this class only

    // Private access modifier play the critical role

    // to restrict the access of the constructor to the outsider.

    private Singleton()

    {

    }

    // Obtain instance of Singleton class with the help of

    // Singleton.getInstance() method.

    public static synchronized Singleton getInstance()

    {

      if(singleton==null)

      {

            singleton=new Singleton();

      }

        return singleton;

    }

    /// clone() method ....

    // additional stuff ...

}

Key points

1)      Singleton object is thread safe

2)      Only one thread will execute the getInstance() method that will reduce the concurrency.

3)      Every time getInstance() method is called additional housekeeping task executed to achieve mutual exclusion among the thread…

Code snippet 5:

Optimize the concurrency by locking only those piece of code that need the mutual exclusion.

package com.ashish.singleton;

public class Singleton {

      // declaring singleton field as static field

      // this field has static nature and will shared among all

      // instance of this class.

      private static Singleton singleton = null;

     

// Sync lock to lock the object access.

      private static Object SYNC_LOCK = new Object();

      // restrict object creation to this class only

      // Private access modifier play the critical role

      // to restrict the access of the constructor to the outsider.

      private Singleton() {

      }

      // Obtain instance of Singleton class with the help of

      // Obtain instance of Singleton class with the help of

      // Singleton.getInstance() method.

      public static Singleton getInstance() {

            if (singleton == null) {

                  synchronized (SYNC_LOCK) {

                        if (singleton == null) {

                              singleton = new Singleton();

                        }

                  }

            }

            return singleton;

      }

      // / clone() method ....

      // additional stuff ...

}

Double null check required because

1)      if more than one thread concurrently check for the null check condition

2)      Only one thread at a time obtain the monitor to execute the critical section ( mutex section)

3)      Try to check any thread initializes the singleton object or not? If yes than avoid re-initialization of singleton object and access the existing object reference.