精品永久久福利一区二区,久久99精品久久只有精品,狠狠色丁香久久婷婷综合图片

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

Fri, 07 Sep 2007 15:22:00 GMT

4.解决多线�E�问�?br />上一��实现的Singleton只能在单�U�程环境中��用，在多�U�程环境中会出现很多问题�Q�看Instance()实现代码�Q?br />

1 static Singleton& Instance() {
2     if (0 == _instance) { //1
3         _instance = new Singleton(); //2
4         atexit(Destroy);
5     }
6     return *_instance; //3
7 }

考虑如下情况�Q�线�E�一调用Instance()�Q�进�?/1�Q? == _instance �q�回true�Q�线�E�一于是�q�入//2。这时候线�E�一被挂��P��U�程二开始执行，�U�程二调用Instance()�Q�进�?/1�Q�发�? == _instance 仍然�q�回true�Q�线�E�二于是也进�?/2�Q�线�E�二�l�箋执行�?/3直到�q�回。这时候线�E�一被唤醒，�l�箋�?/2开始执行，�q�将会覆盖线�E�二创徏的_instance�Q�线�E�一�l�箋执行�?/3直到�q�回...

解决�Ҏ��很简单，引入相关同步对象(synchronization object)��p��了，例如在win32�q�_��下可以如下实玎ͼ�
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*/

有了同步对象很容易就能够写出如下代码�Q?br />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虽然多线�E�安全，性能却受��C��影响。从Instance()中可以看刎ͼ�实际上仅仅当0 == _instance为true时才需要Lock。你很容易就写出如下代码�Q?br />

1 static Singleton& Instance() {
2     if (0 == _instance) {
3         Lock lock(_mutex);
4         _instance = new Singleton();
5         atexit(Destroy);
6     }
7     return *_instance;
8 }

但是�q�样�q�是会��生竞争条�?race condition)�Q�一�U�广��Z�h知的做法是��用所谓的Double-Checked Locking�Q?br />

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机制看�v来像是一个完��的解决�Ҏ��Q�但是在某些条�g下仍然不行。简单的��_��~�译器�ؓ了效率可能会重排指��o的执行顺�?compiler-based reorderings)。看�q�一行代码：

_instance = new Singleton();

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

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

当编译器优化后，如果�U�程一执行�?后被挂�v。线�E�二开始执行�ƈ发现0 == _instance为false�Q�于是直接return�Q�而这时Singleton对象可能�q�未构造完成，后果...

上面说的�q�只是单处理器的情况�Q�在多处理器(multiprocessors)的情况下�Q�超�U�程技术必然会混合执行指��o�Q�指令的执行��序更无法保障。关�?span style="COLOR: #333399">Double-Checked Locking的更详细的文章，��L��Q?br />The "Double-Checked Locking is Broken" Declaration

5.使用volatile关键�?br />��Z��说明问题�Q�请先考虑如下代码�Q?br />

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()开启了一个线�E�，该线�E�在while循环中检��bool标记_stopped�Q�看是否该��l�执行。如果想要结束这个线�E�，调用thread.stop()应该没问题。但是需要注意的是编译器很有可能对_stopped的存取进行优化。如果编译器发现_stopped被频�J�存�?_stopped在while循环�?�Q�编译器可能会考虑��_stopped�~�存到寄存器中，以后_stopped��会直接从寄存器存取。这时候如果某个线�E�调用了thread.stop()�Q�对_stopped的修改将不会反映到寄存器中，thread��会永远循环下去...

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

1 //singleton.h�?/span>
2 static Singleton *_instance;
3 //改�ؓ
4 static Singleton * volatile _instance;
5
6 //singleton.cpp�?/span>
7 Singleton* Singleton::_instance = 0;
8 //改�ؓ
9 Singleton* volatile Singleton::_instance = 0;

6.��Singleton泛化为模�?br />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*/

��试代码�Q?br />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的析构问�?/strong>
到此Singleton已经��比较完善了�Q�但是依然算不上完美�Q�因为到现在只是解决了多�U�程问题�Q�加入了模板支持�Q�对�?span style="COLOR: #333399">KDL problem(The Dead Reference Problem)依然没法解决�Q�可以说在实现Singleton模式�Ӟ��最大的问题��是多个有依赖关�pȝ��Singleton的析构顺�?/span>。虽�?em style="COLOR: #333399">Modern C++ Design中给��Z��解决�Ҏ��Q�但�?span style="COLOR: #333399">Loki的实现太�q�复杂，在此��׃��详细说明了，有兴��的可以看看Modern C++ Design�Q�当然了�Q?span style="COLOR: #333399">Loki库中用策略模式实现的Singleton也很不错�Q?br />

蚂蚁�l�结�?/a> 2007-09-07 23:22 发表评论

非完��C++ Singleton实现[1]

Fri, 07 Sep 2007 06:49:00 GMT

Singleton模式是一�U�非常简单的设计模式�Q�这�U�模式很常用也很�Ҏ��被滥用。当你设计应用程序的时候，�l�常会遇到某些对象在整个�E�序的生命周期应该仅有一个实例的情况�Q�比�?span style="COLOR: #333399">File System�Q�Graphic System�Q�Logging Utility�Q�这时候就可以用到Singleton模式。Singleton模式�?span style="COLOR: #333399">GOF中描�q�如下：

        Ensure a class only has one instance, and provide a global point of access to it.

Singleton模式的定义很��单，实现也有N多种�Q�但是却很难扑ֈ�一个称得上“完美”的。实��C��个完��的Singleton比想象中要难的多�Q�下面探索性的来实��C��个非完美的�?br>
1.典型实现
在C++中，Singleton模式的典型实现如下：

1 // Header file Singleton.h
2 class Singleton {
3 public :
4     static Singleton& Instance() { // Unique point of access
5         if (0 == _instance)
6             _instance = new Singleton();
7         return * _instance;
8     }
9     void DoSomething();
10 private :
11     Singleton(); // Prevent clients from creating a new Singleton
12     ~Singleton(); // Prevent clients from deleting a Singleton
13     Singleton(const Singleton&); // Prevent clients from copying a Singleton
14     Singleton& operator=(const Singleton& );
15 private :
16     static Singleton *_instance; // The one and only instance
17 };
18
19 // Implementation file Singleton.cpp
20 Singleton* Singleton::_instance = 0;

通过��Singleton的构造函数设为private可以��止客户代码直接创徏Singleton对象�Q�除此之外，Singleton的copy constructor和copy assignment operator都�ؓprivate且仅有声明没有实玎ͼ��止了客户代码拷贝Singleton对象。唯一可以创徏Singleton对象的是Singleton自己的静态成员函数Instance�Q�这样就在编译器保证了Singleton实例的唯一性。上面这些是在C++中实现Singleton模式最基本的要炏V�?br>
Instance�Ҏ��保证只有在第一�ơ调用时才会生成Singleton对象�Q�以后的调用只是��单返回唯一的已存在的实例。Instance�Ҏ��实际上实现的�?span style="COLOR: #333399">懒惰初始�?lazy initialize)�Q?/em>如果�E�序中根本没有用到Singleton对象�Q�也��根本不会��生Singleton的实例，�q�在Singleton对象很少使用且创建Singleton对象开销比较大的情况下特别有用�?/p>
客户代码现在可以�q�样使用Singleton�Q?/p>
1 Singleton &s = Singleton::Instance();
2 s.DoSomething();

�q�需要说明的是Singleton的析构函敎ͼ�析构函数也�ؓprivate可以��止客户写出如下代码。如果某个客户写��Z��如下代码�Q�随后的对Singleton的访问就会导致�ؓ定义行�ؓ�Q�因为Singleton对象已经不存在�?br>

1 Singleton *p = & Singleton::Instance();
2 delete p;

2.引入smart pointer
上面的实现算是一个好的实现吗�Q�当然不是，或许�q�一个正��的实现都算不上。如果你惛_��合，当然没问题，上面的代码大多数情况下可以工作的很好。也�怽�已经注意��C��一些问题，比如说在上面的代码中只有new没有delete。是的，你说会发生memory leak对吧�Q�其实memory leak都不是主要的问题�Q�所有的��C��操作�pȝ��在进�E�结束的时候都会对内存很好的进行回收。比memory leak更值得让�h担忧的是resource leak�Q�如果Singleton在构造函��C��h��了某些资源：�|�络�q�接�Q�文件句柄，数据库连接等。这些资源将得不到释放�?br>
唯一修正resource leak的方法就是在�E�序�l�束的时候delete _instance。当然了�Q�用smart pointer再好不过�Q�在�q�里用auto_ptr��可以满��需要了(如果你还不知道smart_ptr是什么，��q��旉��熟悉C++标准库吧)�Q�修改后的代码如下：

1 // Header file Singleton.h
2 class Singleton {
3 public :
4     static Singleton& Instance() { // Unique point of access
5         if (0 == _instance.get())
6             _instance.reset(new Singleton());
7         return * (_instance.get());
8     }
9     void DoSomething(){}
10 private :
11     Singleton(){} // Prevent clients from creating a new Singleton
12     ~Singleton(){} // Prevent clients from deleting a Singleton
13     Singleton(const Singleton&); // Prevent clients from copying a Singleton
14     Singleton& operator=(const Singleton& );
15 private :
16     friend auto_ptr<Singleton> ;
17     static auto_ptr<Singleton> _instance; // The one and only instance
18 };
19
20 // Implementation file Singleton.cpp
21 auto_ptr<Singleton> Singleton::_instance;

3.用atexit替换smart pointer
C++�q�没有规定不�?span style="COLOR: #333399">�~�译单元(translation unit�Q�简单说��是一个可�~�译的cpp文�g)中static对象的初始化��序。如果一个程序中有多个Singleton对象�Q�那么这些Singleton对象的析构顺序也��是��L��的。很昄��Q�当多个Singleton对象有依赖关�p�L��Q�smart pointer�Ҏ��无法保证Singleton的析构顺序�?br>
msdn中对atexit描述如下�Q?/p>
The atexit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to atexit create a register of functions that are executed in last-in, first-out (LIFO) order. The functions passed to atexit cannot take parameters. atexit use the heap to hold the register of functions. Thus, the number of functions that can be registered is limited only by heap memory.

需要说明的是atexit�q�不比smart pointer好多��，LIFO的保证对于有复杂依赖关系的多个Singleton依然束手无力�Q�但是用atexit替换smart pointer却是必须的，它是设计完美Singleton的基��?br>

#如果你疑惑atexit��Z��么还是不行，误��虑下面的情况：
NOTE�Q�下面的情况�?em>Modern C++ Design中叫�?em style="COLOR: #333399">KDL(Keyboard,Display,Log)problem�?br>
某个�E�序中��用了如下3个Singleton�Q?span style="COLOR: #333399">Keyboard�Q?span style="COLOR: #333399">Display�Q?span style="COLOR: #333399">Log�?span style="COLOR: #333399">Keyboard�?span style="COLOR: #333399">Display分别对应于计��机的键盘和昄��器，Log用来记录错误信息。假讑ֽ�Keyboard�?span style="COLOR: #333399">Display的构造函数和析构函数出现错误时会调用Log记录错误信息�Q��ƈ且构造和析构��D��的�Q何错误都会终止程序�?br>
在程序启动时�Q�如�?span style="COLOR: #333399">Keyboard构造成功，Display构造失败，很显然在Display的构造函��C��会构�?span style="COLOR: #333399">Log而且��p�|信息会被Log记录�Q�根据假设这时候程序准备退出，atexit注册的函数将会按LIFO的顺序被调用。因�?span style="COLOR: #333399">Keyboard先于Log构造，所�?span style="COLOR: #333399">Log先于Keyboard析构�Q�但是当�׃��某种原因Keyboard在析构时��p�|�Q�想要调�?span style="COLOR: #333399">Log记录错误信息�Ӟ��Log早已被销毁，则Log::Instance()��会��D��未定义行为�?br>

#atexit的严重问题：
从上面的例子可以看出�Q�atexit和smart pointer相比仅仅是有LIFO的保证而已�Q�这��L��保证貌似也不怎么有效�Q�因为atexit跟smart pointer一样也无法解决KDL probleam�?br>
atexit�׃��LIFO带来了另外的问题�Q�看下面的代码：

1 #include <cstdlib>
2 void Bar() {
3     ...
4 }
5 void Foo() {
6     std::atexit(Bar);
7 }
8 int main() {
9     std::atexit(Foo);
10     return 0 ;
11 }

上面的小�D�代码用atexit注册了Foo�Q�Foo调用了std::atexit(Bar)。当�E�序退出时�Q�根据atexit的LIFO保证�Q�Bar在Foo之后注册�Q�因此Bar应该在Foo之前调用�Q�但是当Bar注册的时候Foo已经调用了，Bar�Ҏ��没有机会能够在Foo之前调用。这明显自相矛盾对吧�Q�没办法�Q�C++标准好像忽视了这一点，因此如果�c�M��代码被调用，肯定不会有什么好的结果，好一�Ҏ��resource leak�Q�差一点估计程序就崩溃了！�Q�！

atexit的这个问题跟Singleton有关�p�d��Q�当然有�Q�如果在一个Singleton的析构函��C��调用atexit��׃��出现上述问题。即�?span style="COLOR: #333399">KDL problem中，如果Keyboard�?span style="COLOR: #333399">Display都构造成功，�?span style="COLOR: #333399">Keyboard�?span style="COLOR: #333399">Display��L��一个析构失败时�Q?span style="COLOR: #333399">Keyboard�?span style="COLOR: #333399">Display在析构函��C��会构�?span style="COLOR: #333399">Log�Q?span style="COLOR: #333399">Log的构造函��C��间接调用atexit。oops!!!�Q�可怕的未定义行为�?br>
看到�q�里你一定对atexit相当失望�Q�貌似它带来的好处多于坏处。但是请你相信，如果适当设计�Q�atexit在后面的Singleton攚w��中会�v到很重要的作用�?br>
用atexit后的代码�Q?/p>
1 // Header file Singleton.h
2 class Singleton {
3 public :
4     static Singleton& Instance() { // Unique point of access
5         if (0 == _instance) {
6             _instance = new Singleton();
7             atexit(Destroy); // Register Destroy function
8         }
9         return * _instance;
10     }
11     void DoSomething(){}
12 private :
13     static void Destroy() { // Destroy the only instance
14         if ( _instance != 0 ) {
15             delete _instance;
16             _instance = 0 ;
17         }
18     }
19     Singleton(){} // Prevent clients from creating a new Singleton
20     ~Singleton(){} // Prevent clients from deleting a Singleton
21     Singleton(const Singleton&); // Prevent clients from copying a Singleton
22     Singleton& operator=(const Singleton& );
23 private :
24     static Singleton *_instance; // The one and only instance
25 };
26
27 // Implementation file Singleton.cpp
28 Singleton* Singleton::_instance = 0;

你有没有仔细考虑�q�Destroy中的_instance = 0;�q�一行代码，上述代码实际上实现的�?em style="COLOR: #333399">不死鸟模�?The Phoenix Singleton)�Q?/em>所谓不死鸟�Q�就跟一辉一样可以死而复生。上面的代码可以解决本文最早提出的KDL problem�Q�即如果Keyboard析构��p�|�Q�虽�?span style="COLOR: #333399">Log已经析构�Q�但是由于Destroy中的_instance = 0;�q�一行代码，Log::Instance()��会创徏一个新�?span style="COLOR: #333399">Log对象�Q�程序将会表现良好。当然了�Q?span style="COLOR: #993366">Phoenix Singleton仅能用于无状态的Singleton�Q�如�?span style="COLOR: #333399">Log需要保存某些状态，Phoenix Singleton也不会带来�Q何好处。你当然可以用某些方法维�?span style="COLOR: #993366">Phoenix Singleton的状态，但是在做之前先想想看是否值得�Q�维持状态可能会使Singleton变得特别复杂�?br>
上面�?span style="COLOR: #993366">Phoenix Singleton已经可以满��大部分需要，如果你的Singleton没有涉及到多�U�程�Q�多个Singleton之间也没有依赖关�p�，你大可以攑ֿ�使用。但是如果你用到多线�E�，或者你的Singleton关系�?span style="COLOR: #333399">KDL般复杂，或者你觉得�Ҏ��一个Singleton都敲同样的代码让你厌烦。在后面几篇会有一�?span style="COLOR: #993366">多线�E�安�?/span>的，能够解决多个Singleton依赖关系的，��Z��模板的Singleton实现�?br>

蚂蚁�l�结�?/a> 2007-09-07 14:49 发表评论

精品永久久福利一区二区,久久99精品久久只有精品,狠狠色丁香久久婷婷综合图片

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

非完���C++ Singleton实现[1]

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

非完��C++ Singleton实现[1]