singleton and public static variable Java

Question

I have 2 options:

1. Singleton Pattern

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

2. using a static final field

   private static final Singleton singleton = new Singleton();
   
   public static Singleton getSingleton() {
       return singleton;
   }
   

Whats the difference? (singlethreaded or multithreaded)

Updates: I am aware of Bill Pugh or enum method. I am not looking for the correct way, but I have only used 1. Is there really any difference b/w 1 or 2?

Answer 1

The main difference is that with the first option , the singleton will only be initialised when getInstance is called, whereas with the second option, it will get initialized as soon as the containing class is loaded.

A third (preferred) option which is lazy and thread safe is to use an enum:

public enum Singleton {
    INSTANCE;
}

Answer 2

There is one difference:

Solution 1 is a lazy initialization, the singleton instance will be created on the first invoke of getInstance

Solution 2 is a eager initialization, the singleton instance will be create when the class loades

They both are thread safe, calling the second one multi threaded is a little misleading

Answer 3

The 1st solutions appears to be lazier, but actually not.

A class is initialized when a static method/field is accessed for the 1st time.

It's likely that getInstance() is the only publicly accessible static method/field of the class. That's the point of singleton.

Then the class is initialized when someone calls getInstance() for the 1st time. That means the two solutions are essentially the same in laziness.

Of course, the 2nd solutions looks better and performs better.

Answer 4

So, with the update both options above are thread-safe. However the synchronized option requires each thread that calls instance to acquire this lock thereby reducing performance if this is done a lot. Also, using synchronized at the method level has the potential issue of using a publicly available lock (the class itself) that therefore if some thread acquires this lock (which it could) you could end up with deadlock. The static final option is more performant but does not do lazy initialization of the singleton (which might not be an issue depending on the system).

Another option that allows thread-safe lazy init of the Singleton is as follows:

 public class MySingleton{
      private static class Builder{
          private static final MySingleton instance = new MySingleton();
      }

      public static MySingleton instance(){
           return Builder.intance;
      }
 }

This works because the static inner class is guarenteed to be initialized before any method in the containing class is executed.