Singleton [Double-Checked Locling] 双重加琐优化

本文链接：https://blog.youkuaiyun.com/testing2007/article/details/4288591

本文介绍了一种使用双检锁机制实现线程安全单例模式的方法。通过Mutex类实现互斥锁，并利用Lock类确保实例唯一且线程安全地创建。通过volatile关键字避免编译器优化，确保多线程环境下正确执行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Double-Checked Locking 实现：

同步类：

synobj.h

1 #ifndef SYNOBJ_H
2 #define SYNOBJ_H
3
4 #include <windows.h>
5
6 #define CLASS_UNCOPYABLE(classname) /
7       private : /
8      classname##( const classname##&); /
9      classname##& operator=( const classname##&);
10
11 class Mutex {
12      CLASS_UNCOPYABLE(Mutex)
13 public :
14      Mutex() :_cs() { InitializeCriticalSection(&_cs); }
15      ~Mutex() { DeleteCriticalSection(&_cs); }
16       void lock() { EnterCriticalSection(&_cs); }
17       void unlock() { LeaveCriticalSection(&_cs); }
18 private :
19      CRITICAL_SECTION _cs;
20 };
21
22 class Lock {
23      CLASS_UNCOPYABLE(Lock)
24 public :
25      explicit Lock(Mutex& cs) :_cs(cs) { _cs.lock(); }
26      ~Lock() { _cs.unlock(); }
27 private :
28      Mutex& _cs;
29 };
30
31 #endif /*SYNOBJ_H*/

有了同步对象很容易就能够写出如下代码：
singleton.h

1 #ifndef SINGLETON_H
2 #define SINGLETON_H
3
4 #include "synobj.h"
5
6 class Singleton {
7 public :
8 static Singleton& Instance() { // Unique point of access

If ( 0 == _instance)

{ // 因为 lock 只对 0 == _instance 为 true 才有效，所以为了优化就再加入了一个判断。
9                Lock lock(_mutex);
10                if (0 == _instance) {
11                      _instance = new Singleton();
12                      atexit(Destroy); // Register Destroy function
13                    }

}
14           return *_instance;
15      }
16       void DoSomething(){}
17 private :
18       static void Destroy() { // Destroy the only instance
19           if ( _instance != 0 ) {
20              delete _instance;
21              _instance = 0;
22          }
23      }
24      Singleton(){} // Prevent clients from creating a new Singleton
25      ~Singleton(){} // Prevent clients from deleting a Singleton
26      Singleton( const Singleton&); // Prevent clients from copying a Singleton
27      Singleton& operator=( const Singleton&);
28 private :
29       static Mutex _mutex;
30       static Singleton volatile *_instance; // The one and only instance