Singleton Class ?

[Saurabh Naik]

Hello
Please explain me the meaning of Singleton class ? In lot of interviews I faced the question.. I searched on net but does not get the satisfied answer.

Thank you

[Pawan Arora]

A class whose number of instances that can be instantiated is limited to one is called a singleton class. Thus, at any given time only one instance can exist, no more.

simply like this: final foo a=new foo();

[Muhammad Khojaye]

GOF says "Ensure a class only has one instance, and provide a global point of access to it."

most simple way to show a Singleton

    
public class Singleton {

    private final static Singleton instance = new Singleton();
 
    private Singleton() {} 
 
    public static Singleton getInstance() { 
        return instance;
    }
}

use a static initializer so our "instance" will be initialized only when it is first accessed.

    
public class Singleton {

    private final static Singleton instance = null;
 
    static {
        instance = new Singleton(); 
    }
 
    private Singleton() {}
}

Or you might check if it is initialized in getInstance method.

   
public class Singleton {

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

Another solution would be to use enum as Joshua Bloch suggests in his book(Effective Java).

    
enum Singleton{
  /** single instance of this class */
  INSTANCE;
 
  /** a method */
  public void doSomething(){
 
  }
}

Enum's classes are better than the approaches using private constructors . It is more concise and provides the guarantee against multiple instantiation, even when dealing with serialization and/or reflection. (See Item 3 of Effective Java)

[Rob Spoor]

Muhammad Ali Khojaye wrote:use a static initializer so our "instance" will be initialized only when it is first accessed.

    
public class Singleton {

    private final static Singleton instance = null;
 
    static {
        instance = new Singleton(); 
    }
 
    private Singleton() {}
}

1) That does not compile; you can't give a final field a value twice (first null, then a Singleton object)
2) This code will be just as efficient as "private final static Singleton instance = new Singleton();". Both will create the variable only when the class is loaded first.

Or you might check if it is initialized in getInstance method.

public class Singleton {

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

Ah, the dreaded double checked locking "pattern". Read this to see why it should not be used in that version.

You also forgot one of the easiest ways:

public class Singleton {

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

These days, the locking overhead of using synchronized is not as big of a performance hit as it used to be. It's quote reasonable to use it.

[Muhammad Khojaye]

Muhammad Ali Khojaye wrote:use a static initializer so our "instance" will be initialized only when it is first accessed.

    
public class Singleton {

    private final static Singleton instance = null;
 
    static {
        instance = new Singleton(); 
    }
 
    private Singleton() {}
}

1) That does not compile; you can't give a final field a value twice (first null, then a Singleton object)

Correct.

Or you might check if it is initialized in getInstance method.

public class Singleton {

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

Ah, the dreaded double checked locking "pattern". Read this to see why it should not be used in that version.

Correct.

Thanks.