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

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

//为了防止编译器优化加入volatile这个修饰关键字
31 };
32 
33 #endif/*SINGLETON_H*/

singleton.cpp

1 #include "singleton.h"
2 
3 Mutex Singleton::_mutex;
4 Singleton* volatile Singleton::_instance = 0; //为了防止编译器优化加入volatile这个修饰关键字