Is the singleton pattern prone to thread safety problems?

Question

Is the singleton pattern prone to thread safety problems? If so, what are the best methods to work around them?

Answer 1

It is heavily depend on the programming language specification & how thread safety is you implemented.

For example: code provided below uses double-checked locking, which should not be used prior to J2SE 5.0, as it is vulnerable to subtle bugs.

public class Singleton {
        private static volatile Singleton instance = null;

        private Singleton() {   }

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

Here is a referencing article on how to correctly implement thread safe Singleton Pattern in C#.

Answer 2

If well implemented, with threading in mind, a singleton will be thread safe.

There are many implementations in many languages that are not thread safe - see this article by Jon Skeet regarding Singleton in C#. Most of the implementations suffer.

The best ways to "work around them" is to know your language, how it works with threads and ensure the code is thread safe.

Just to note - even if singletons were somehow thread safe by nature, you should not use them for this reason. They tend to be overused and make for un-testable code as a source of global state.

Answer 3

Yes, as other answers have noted, it can be implemented in a thread safe manner. That said, it tends to be prone to issues since it already requires careful implementation to avoid subtle issues due to initialization order. The possibility of multiple thread access exacerbates these concerns.

And it's still global state. Even if the singleton itself is threadsafe, the reliance on global state tends to add errors to the actual multithreaded code.