Singleton object- In static block or in getInstance(); which should be used

Question

Below are two ways to implement a singleton. What are the advantages and disadvantages of each?

Static initialization:

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

Lazy initialization is:

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

**NOTE:** static blocks can access only static variables defined outside static block directly — BlackBeard, Mar 19 '14 at 06:08

score 10 · Accepted Answer · edited Dec 15 '15 at 18:28

Synchronized Accessor

public class Singleton {
    private static Singleton instance;

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

lazy load
low perfomance

Double Checked Locking & volatile

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

lazy load
high perfomance
JDK should be 1,5 ++

On Demand Holder idiom

public class Singleton {

    public static class SingletonHolder {
        public static final Singleton HOLDER_INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.HOLDER_INSTANCE;
    }
}

lazy load
high performance
cant be used for non static class fields

score 6 · Answer 2 · answered Mar 19 '14 at 06:17

First one is eager initialisation. eager initialization creates the instance even before it’s being used and that is not the best practice to use.

Second one is Lazy Initialization. Lazy implementation works fine incase of single threaded environment but when it comes to multithreaded systems, it can cause issues if multiple threads are inside the if loop at the same time. It will destroy the singleton pattern and both threads will get the different instances of singleton class.

Please visit: http://www.journaldev.com/1377/java-singleton-design-pattern-best-practices-with-examples#static-block-initialization for more information

Wonderful example for Singleton patterns. Threadsafe seems the best choice. Bummer, reflection can just destroy — BlackBeard, Mar 19 '14 at 06:23

kalyan pvs · Answer 3 · 2014-03-19T06:16:14.517

1

make your class like this

public class Singleton {

private Singleton() {

}

private static Singleton instance;

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

}

and call it like..

Singleton instance = Singleton.getInstance();

edited Mar 19 '14 at 06:16

answered Mar 19 '14 at 06:02

kalyan pvs

14,486
4
41
59

So far, I am using the second approach But In some code I saw that approach too. So, I am not able to decide when that first one is benefecial. – Rahul Rastogi Mar 19 '14 at 06:07
1

@user2155922 First one is same as i am posted with some modifications..but there is a error in your code instance is in static block so it must be static field – kalyan pvs Mar 19 '14 at 06:09
1

@user2155922 and when it comes to the second approch its not valid until your getInstance method is static..otherwise you need to create object to access the getInstance() method then which is not singleton.. – kalyan pvs Mar 19 '14 at 06:11
This happened during typing question...When I was typing the questions It happened. – Rahul Rastogi Mar 19 '14 at 07:04

score 1 · Answer 4 · answered Mar 19 '14 at 06:14

NOTE: static blocks can access only static variables defined outside static block directly. The object you want to restrict to only one instance creation should be static. Your first methods fails during compilation, second method requires you to create the object first
Follow this approach:

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

Ensure no creation of the object elsewhere, so change the constructor to private

score 1 · Answer 5 · answered Sep 27 '18 at 01:09

1

Static initializers cannot throw exceptions and absorb RuntimeExceptions into ClassDefNotFoundException, which does not halt execution. So you could see lots of ClassDefNotFoundException's in your logs and you might not even realize something is wrong until much later because execution continues.

The 2nd method allows RuntimeExceptions to stop execution.

More details here: https://twasink.net/2006/07/07/how-not-to-handle-exceptions-from-static-code-block-in-java/

answered Sep 27 '18 at 01:09

Koz

31
4

This is a great point. Is there no way to intercept. – z atef Jul 07 '22 at 03:45
The links you shared are broken, BTW. – z atef Jul 07 '22 at 03:47

z atef · Answer 6 · 2023-08-25T04:03:30.963

Use static block if you need some things to be initliazedz when the app starts. f.ex, one may want to load some properties from some file that do useful stuff....etc

    static {
    instance = new Singleton();
    loadStuff();
}

Use lazy initialization

class Singleton {
    private Singleton instance;
    public Singleton getInstance(){
        if (instance == null) instance = new Singleton();
        loadStuff()
        return instance;
    }
}

and loadStuff will only be triggered when the Singleton.getInstance() is first called.

Singleton object- In static block or in getInstance(); which should be used

6 Answers6

Linked