Thread safe singleton implementation in C++
c++, design-patterns, multithreading
Solution
No, this is not thread safe because the static local is not guarded in any way. By default a static local is not thread safe. This means you could run into the following issues
- Constructor for the singleton runs more than once
- The assignment to the static is not guaranteed to be atomic hence you could see a partial assignment in multi-threaded scenarios
- Probably a few more that I'm missing.
Here is a detailed blog entry by Raymond Chen on why C++ statics are not thread safe by default.
- http://blogs.msdn.com/oldnewthing/archive/2004/03/08/85901.aspx
Problem
The following is a well known implementation of singleton pattern in C++. However, I'm not entirely sure whether its thread-safe. Based upon answers to similar question asked here previously, it seems it is thread safe. Is that so? ``` //Curiously Recurring Template Pattern //Separates a class from its Singleton-ness (almost). #include <iostream> using namespace std; template<class T> class Singleton { Singleton(const Singleton&); Singleton& operator=(const Singleton&); protected: Singleton() {} virtual ~Singleton() {} public: static T& instance() { static T theInstance; return theInstance; } }; // A sample class to be made into a Singleton class MyClass : public Singleton<MyClass> { int x; protected: friend class Singleton<MyClass>; MyClass() { x = 0; } public: void setValue(int n) { x = n; } int getValue() const { return x; } }; ```