Singleton Pattern Recommended Method

Question

Case 1:

public class Singleton {

  public static final Singleton INSTANCE = new Singleton();

  private Singleton() {
    ...
  }
}

Case 2:

public class Singleton {

  private static final Singleton INSTANCE = new Singleton();

  private Singleton() {
    ...
  }

  public static Singleton getInstance() {
    return INSTANCE;
  }
}

Is the second method the recommended way to implement the Singleton design pattern, because I have never seen the first one in any example for Singleton pattern.

No real difference. A getter could be useful for lazy instantiation, but you are not doing that (other than what the classloader already does). — Thilo, Nov 29 '16 at 10:07
ahh yes. I think lazy vs eager remains the only difference then. Thanks! (unless there are some more differences that we are overlooking) — alpha_ulrich, Nov 29 '16 at 10:09
But if the application benefits from lazy loading, will you still recommend use of enum? — alpha_ulrich, Nov 29 '16 at 10:18

marstran · Accepted Answer · 2016-11-29T11:43:53.660

3

Without going into all the stuff about singletons being an antipattern (but you should read up on it!), the currently best way to make a singleton in Java is to use an enum.

public enum Singleton {
    INSTANCE;
}

The reason this is better is because the JVM guarantees that only one instance of the enum (per classloader) will exist at any time. It is thread safe, and you cannot use reflection to create another instance of the singleton.

Enum-values are also lazily instantiated, so you won't create the singleton before you access Singleton.INSTANCE the first time.

edited Nov 29 '16 at 11:43

answered Nov 29 '16 at 10:11

marstran

26,413
5
61
67

didn't know enum values are lazily instantiated. thanks for your info! – alpha_ulrich Nov 30 '16 at 10:33

score 1 · Answer 2 · edited May 23 '17 at 12:30

1

The best way to make a singleton is to use Enum.

public enum Foo {
    INSTANCE;
}

What is an efficient way to implement a singleton pattern in Java?

edited May 23 '17 at 12:30

Community

1
1

answered Nov 29 '16 at 10:07

Umair Zahid

135
9

2

Can you please elaborate on why it is better than the above two methods? – alpha_ulrich Nov 29 '16 at 10:08
http://stackoverflow.com/questions/70689/what-is-an-efficient-way-to-implement-a-singleton-pattern-in-java?rq=1 – Thilo Nov 29 '16 at 10:09

score 0 · Answer 3 · answered Nov 29 '16 at 10:23

In your example, case 1 is more simple, so it's better. But just wonder what happen if your constructor function is more complicated with some parameters. At this time, you really need some thing like this:

public class Singleton {

 private static final Singleton INSTANCE;

 private Singleton(string a, string b, string c) {
   ...
 }

public static Singleton getInstance(string a, string b, string c) {
   if (INSTANCE != null) { //note in multiple thread env, need add synchronize here.
       ......
   }
   return INSTANCE;
}
}

SachinSarawgi · Answer 4 · 2016-11-29T10:33:09.270

The first process of creating Singleton object created the instance of Singleton class even before it is being used and that is not the best practice to use.

Also the same problem exists in second implementation. My preferred way of singleton instance creation:

 private static final Singleton INSTANCE = null;
 public static Singleton getInstance(){
      if(INSTANCE == null)
        INSTANCE = new Singleton();
    return INSTANCE;
 }

Above implementation of Singleton instance creation is okay in single threaded environment but in case of multi-threaded environment two threads may access if block at same time so they will have different instances. This could be solved as below:

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

Hope this helps.

Javaci · Answer 5 · 2016-12-03T22:52:27.840

This how I implement singleton with enum

import static collections.concurrancy.ConcurrentHashMapInstanceEnum.STAFF;
public enum ConcurrentHashMapInstanceEnum {
    STAFF;
    private ConcurrentHashMap<Integer,Person> concurrentHashMap = null;

    private ConcurrentHashMapInstanceEnum() {
            concurrentHashMap = new ConcurrentHashMap(10, 5f, 4);
    }

    public ConcurrentHashMap getConcurrentHashMap() {
        return concurrentHashMap;
    }
}

and this is how to reach in a thread...

 staffList = STAFF.getConcurrentHashMap()

score -1 · Answer 6 · answered Nov 29 '16 at 10:12

-1

Yes Obviously the second method is preferred way to implement Sigleton pattern , Inside getInstance() you have to check if instance is already created then return the same and Only create new instance if there is No instance of the class.

Also Make getInstance method as static method.

answered Nov 29 '16 at 10:12

Abhilash Arjaria

142
2
10

You would also have to use the Method way of getting it when object instantantiation would become more complex. Your example is simply because it calls the default constructor. Think of a scenario where your singleton object would have to be obtain by a factory pattern. – Dirk Schumacher Nov 29 '16 at 10:14
Yes So That's why I suggest to prefer the way of use method getInstanse instead of constructor way. when you use factory pattern getInstanse will work. – Abhilash Arjaria Nov 29 '16 at 10:53

Singleton Pattern Recommended Method

6 Answers6