CODEWITHSUNDEEP
c++multithreadingdesign-patterns
Ankur
Ankur

Reputation: 11749

Thread safe singleton implementation in C++

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; }
};

Upvotes: 12

Views: 13564

Answers (4)

Silviu
Silviu

Reputation: 123

If you're still interest on this topic and if you're using a C++ 11 standard compiler you can find here a proposal of the singleton pattern in a multithreaded environment.

Upvotes: 0

Makram Ghazzaoui
Makram Ghazzaoui

Reputation: 11

IT IS NOT THREAD SAFE. To become thread safe you should add a check before the lock (semaphore lock) and an other check after the lock. And then you are sure that even in simultaneous call from different threads you provide one instance.

Upvotes: 1

JaredPar
JaredPar

Reputation: 755457

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.

Upvotes: 13

Gordon Childs
Gordon Childs

Reputation: 36169

It's not threadsafe, unless you configure your compiler to generate threadsafe code for static accesses.

However, it's better that the code be self contained, so I'd add a mutex here and there.

Upvotes: 0

Related Questions