singleton design pattern with thread safe

Question

I read the reason for synchronize the new instance creation is two threads can access getInstance same time and find that _instance is null and create two instances of Singleton class. So in order to eliminate that we synchronized it. But again how come a double-checked locking method introduce again check whether the instance is null inside the Synchronized block. Does this necessary? Once a code block is synchronized it already thread safe know?

public class Singleton {
        private static Singleton _instance = null;

        private Singleton() {   }

        public static Singleton getInstance() {
                if (_instance == null) {
                      synchronized (Singleton.class) {
                          _instance = new Singleton(); // why need to again check null
                      }
                }
                return _instance;
        }
}

possible duplicate of Pattern for lazy thread-safe singleton instantiation in java — user1937198

barak manos barak manos · Accepted Answer · 2014-04-27T15:38:53

The synchronized block will be executed sequentially (i.e., one thread at a time), but that's not enough, because the second call to _instance = new Singleton() might override the first one.

It's a plausible scenario if one context-switch takes place immediately after the first thread evaluates the _instance == null expression, and no other context-switch takes place until another thread evaluates the _instance == null expression.

Therefore, once inside the synchronized block, the current thread has to make sure that _instance is still null before setting it to a new Singleton().

singleton design pattern with thread safe

1 Answers