是否可以自动对 singleton object 线程安全进行原子操作

Question

I have singleton object shared between two units operating on seperate threads. For example,

Thread A Singleton.getInstace().incCounter();

Thread B Singleton.getInstance().decCounter();

Is it possible to implement this atomics to be thread safe without bothering the consumers to do it in thread safe way.

Something like

static Singleton& GetInstance() {

    std::scoped_lock lock(m_mtx);

    static Singleton* singleton = new Singleton();

    return *singleton;
}

I guess this will not work as the lock will be released after the return but incCounter and decCounter will be called without the lock. Is it somehow possible to keep the lock active till atomic operation is completed. Is doing a lock within the incCounter and decCounter the only solution here or in unit A and unit B only solution.

Answer 1

The current lock accomplishes nothing. A static function-local variable is required by the C++ standard to be initialized in exactly one thread. That is, the compiler will ensure that there can be no race conditions on its initialization. So the lock is protecting against something that can't happen.

You need to put a lock in the increment/decrement functions. And they need to lock the same mutex. Though perhaps they could increment/decrement an atomic variable, in which case you don't need a lock at all.

You could (but probably shouldn't) create a new type LockedSingleton which stores a reference to the singleton and a std::unique_lock . This would be what your GetInstance() returns. LockedSingleton would need to have its own increment/decrement functions which it forwards to its internal singleton reference, as well as any other interface functions.

class LockedSingleton
{
private:
  std::unique_lock<std::mutex> lock_;
  Singleton &obj_;

private: //Only friends can construct. Also, non-copyable.
  LockedSingleton(std::mutex &mtx, Singleton &obj)
    : lock_(mtx)
    , obj_(obj)
  {}

  friend Singleton& GetInstance();

public:

  void incCounter() {obj.incCounter();}
  void decCounter() {obj.decCounter();}
    
};

static LockedSingleton GetInstance() {
    static Singleton* singleton = new Singleton();

    return LockedSingleton(m_mtx, *singleton);
}

Note that this only works in C++17 and above, due to guaranteed elision, since LockedSingleton is non-copyable.