Singleton Design Pattern « Caught By Java

Singleton Design Pattern says that there should be only one instance of the class at any time during the running state of the application in which it exists. It means that there should only one instance of the class in the JVM.

If you run the below code it will always return you the same instance every time you call the Singleton.getInstance(). Now will you say that “what is the fun in this? why should I need to have a same instance all the time?”.

Well the answer is to save memory. Instead of creating new instances we can resue the same instance whenever required. But doing so we have to remember that state of the singleton object does not change with upon its usage. That means you cannot just blindly start creating singleton objects for their corresponding classes. Remember object represents a real world entity. That means you and I cannot be a singleton object. Most popular example of a Singleton object is Logger object or a Security Manager object.

As you can see in the code that I have declared the constructor as private, well the purpose is to stop others creating new instances of this class. I am sure you must be aware of that. If you dont never mind, now you know it.

Singleton class maintains a static reference to the only singleton instance created during the first call to Singleton.getInstance() and returns a reference to that instance. Check out that the getInstance method is a static method.

 Java |   copy code | ?  
01 package com.test.singleton;
02  
03 public class Singleton { 
04  
05 private static Singleton object = null; 
06  
07 /** 
08   * Private Constructor.
09   *
10   */ 
11   private Singleton() {
12   } 
13  
14   /**
15    * This method always returns the only instance of the class Singleton. 
16   * @return 
17   */ 
18    public static Singleton getInstance() { 
19      if (object == null) { 
20        synchronized (Singleton.class) {
21          if (object == null) { 
22            object = new Singleton(); 
23            return object; 
24          } 
25        } 
26      } 
27      return object;
28   }
29  
30 }

I have used a class level lock in the synchronized block as instance level lock cannot be acquired in the static context. That means you cannot use "this" reference in a static method. But why I have used a lock?

Let us consider that there are two active threads T1 and T2 and both tries to get the instance of the Singleton class and Singleton.getInstance() has not yet been called by anyone. If T1 is preempted by T2 at Line Number 19 before the assignment is made, the member variable will still be null during the time, and T2 can subsequently enter the if block and we will land up with two distinct singleton instances because T1 is already inside the if block. So we had used a lock at Line Number 20 to make the code thread safe and checked again whether the object is still null nor not.

Also see "How serialization breaks Singleton".

Let us consider that there are two active threads T1 and T2. If T1 is preempted by T2 at Line Number 2 before the assignment is made, the member variable will still be null during the time, and T2 can subsequently enter the if block we will land up with two distinct singleton instances because T1 is already inside the if block. So we need to use lock to make the code thread safe.Let us consider that there are two active threads T1 and T2. If T1 is preempted by T2 at Line Number 2 before the assignment is made, the member variable will still be null during the time, and T2 can subsequently enter the if block we will land up with two distinct singleton instances because T1 is already inside the if block. So we need to use lock to make the code thread safe.

Sharable with

This entry was posted on Thursday, July 2nd, 2009 and is filed under Design Pattern. You can follow any responses to this entry through RSS 2.0. You can leave a response, or trackback from your own site.

#1 by Prakash panigrahi on August 5th, 2009

Quote

Can You tell me if this class will be a deriver calss from one base class which has overridden clone() method i.e the superclass implements clonable interface .Still i can create more then one object in your Singleton class by using clone() method.I think the best way to do this is to make this Singleton class as final ,Let me know if i am wrong.i.e

public static final Singleton getInstance() {

#2 by Aputin on August 5th, 2009

Yes you are correct only when the Singleton has the default constructor as public. But in this Implementation of Singleton we have kept default constructor as private that protects it from being extended.

#3 by Aputin on August 5th, 2009

Any class that has a default constructor as private cannot be extended by any other class. That means this Singleton class will never have a derived class.

#4 by Aputin on August 10th, 2009

Somebody had been asking about how to call a singleton class in java? Well the answer is that in your class just call the static method getInstance() of the singleton class. Like

public void yourMethod() {

…..

// returns the instance of the singleton class
Singleton object = Singleton.getInstance();

// call the method that performs the job.
// Let us say object.log(“log this message”);

}

#5 by Stefaan on August 10th, 2009

What if you initialize a static public or private final INSTANCE in a static {} block? You don’t need to synchronize. The only difference is that you allocate memory from the moment you reference and load the class, I think.

#6 by Aputin on August 11th, 2009

You can use static initializer too but the direct benefit that you get is “Lazy Loading” using this implemenation.

#7 by Aman on August 20th, 2009

Use ENUMS if you are using java 1.5 or above.

Caught By Java

Just another Technology Blog

Singleton Design Pattern

7 Comments

Recent Posts

Categories

Tags

Archives