非完美C++ Singleton实现[2]

非完美C++ Singleton实现[2]

4.解决多线程问题
上一篇实现的Singleton只能在单线程环境中使用，在多线程环境中会出现很多问题，看Instance()实现代码：

1 static Singleton& Instance() {
2 if (0 == _instance) { //1
3 _instance = new Singleton(); //2
4 atexit(Destroy);
5 }
6 return *_instance; //3
7 }
考虑如下情况：线程一调用Instance()，进入//1，0 == _instance 返回true，线程一于是进入//2。这时候线程一被挂起，线程二开始执行，线程二调用Instance()，进入//1，发现0 == _instance 仍然返回true，线程二于是也进入//2，线程二继续执行到//3直到返回。这时候线程一被唤醒，继续从//2开始执行，这将会覆盖线程二创建的_instance，线程一继续执行到//3直到返回...

解决方法很简单，引入相关同步对象(synchronization object)就行了，例如在win32平台下可以如下实现：
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
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 *_instance; // The one and only instance
31 };
32
33 #endif/*SINGLETON_H*/

singleton.cpp

1 #include "singleton.h"
2
3 Mutex Singleton::_mutex;
4 Singleton* Singleton::_instance = 0;
现在的Singleton虽然多线程安全，性能却受到了影响。从Instance()中可以看到，实际上仅仅当0 == _instance为true时才需要Lock。你很容易就写出如下代码：

1 static Singleton& Instance() {
2 if (0 == _instance) {
3 Lock lock(_mutex);
4 _instance = new Singleton();
5 atexit(Destroy);
6 }
7 return *_instance;
8 }
但是这样还是会产生竞争条件(race condition)，一种广为人知的做法是使用所谓的Double-Checked Locking：

1 static Singleton& Instance() {
2 if (0 == _instance) {
3 Lock lock(_mutex);
4 if (0 == _instance) {
5 _instance = new Singleton();
6 atexit(Destroy);
7 }
8 }
9 return *_instance;
10 }
Double-Checked Locking机制看起来像是一个完美的解决方案，但是在某些条件下仍然不行。简单的说，编译器为了效率可能会重排指令的执行顺序(compiler-based reorderings)。看这一行代码：

_instance = new Singleton();

在编译器未优化的情况下顺序如下：
1.new operator分配适当的内存；
2.在分配的内存上构造Singleton对象；
3.内存地址赋值给_instance。

但是当编译器优化后执行顺序可能如下：
1.new operator分配适当的内存；
2.内存地址赋值给_instance；
3.在分配的内存上构造Singleton对象。

当编译器优化后，如果线程一执行到2后被挂起。线程二开始执行并发现0 == _instance为false，于是直接return，而这时Singleton对象可能还未构造完成，后果...

上面说的还只是单处理器的情况，在多处理器(multiprocessors)的情况下，超线程技术必然会混合执行指令，指令的执行顺序更无法保障。关于Double-Checked Locking的更详细的文章，请看：
The "Double-Checked Locking is Broken" Declaration

5.使用volatile关键字
为了说明问题，请先考虑如下代码：

1 class MyThread : public Thread {
2 public:
3 virtual void run() {
4 while (!_stopped) {
5 //do something
6 }
7 }
8 void stop() {
9 _stopped = true;
10 }
11 private:
12 bool _stopped;
13 };
14
15 ...
16
17 MyThread thread;
18 thread.start();
上面用thread.start()开启了一个线程，该线程在while循环中检测bool标记_stopped，看是否该继续执行。如果想要结束这个线程，调用thread.stop()应该没问题。但是需要注意的是编译器很有可能对_stopped的存取进行优化。如果编译器发现_stopped被频繁存取(_stopped在while循环中)，编译器可能会考虑将_stopped缓存到寄存器中，以后_stopped将会直接从寄存器存取。这时候如果某个线程调用了thread.stop()，对_stopped的修改将不会反映到寄存器中，thread将会永远循环下去...

为了防止编译器优化，用volatile关键字就OK了，volatile跟const的用法几乎一样，能用const的地方也都能用volatile。对Singleton来说，修改如下两处即可：

1 //singleton.h中
2 static Singleton *_instance;
3 //改为
4 static Singleton * volatile _instance;
5
6 //singleton.cpp中
7 Singleton* Singleton::_instance = 0;
8 //改为
9 Singleton* volatile Singleton::_instance = 0;

6.将Singleton泛化为模板
singleton.h

1 #ifndef SINGLETON_H
2 #define SINGLETON_H
3
4 #include "synobj.h"
5
6 template<class T>
7 class Singleton {
8 CLASS_UNCOPYABLE(Singleton)
9 public:
10 static T& Instance() { // Unique point of access
11 if (0 == _instance) {
12 Lock lock(_mutex);
13 if (0 == _instance) {
14 _instance = new T();
15 atexit(Destroy);
16 }
17 }
18 return *_instance;
19 }
20 protected:
21 Singleton(){}
22 ~Singleton(){}
23 private:
24 static void Destroy() { // Destroy the only instance
25 if ( _instance != 0 ) {
26 delete _instance;
27 _instance = 0;
28 }
29 }
30 static Mutex _mutex;
31 static T * volatile _instance; // The one and only instance
32 };
33
34 template<class T>
35 Mutex Singleton<T>::_mutex;
36
37 template<class T>
38 T * volatile Singleton<T>::_instance = 0;
39
40 #endif/*SINGLETON_H*/

测试代码：
test.cpp

1 #include "singleton.h"
2
3 class A : public Singleton<A> {
4 friend class Singleton<A>;
5 protected:
6 A(){}
7 ~A(){}
8 public:
9 void DoSomething(){}
10 };
11
12 int main() {
13
14 A &a = A::Instance();
15 a.DoSomething();
16
17 return 0;
18 }

7.Singleton的析构问题
到此Singleton已经算比较完善了，但是依然算不上完美，因为到现在只是解决了多线程问题，加入了模板支持，对于KDL problem(The Dead Reference Problem)依然没法解决，可以说在实现Singleton模式时，最大的问题就是多个有依赖关系的Singleton的析构顺序。虽然Modern C++ Design中给出了解决方案，但是Loki的实现太过复杂，在此就不详细说明了，有兴趣的可以看看Modern C++ Design，当然了，Loki库中用策略模式实现的Singleton也很不错！