Singleton 单件模式及其变体 Double-Checked Locking 双重检查锁模式

1://Singleton.h

2:#pragmaonce

3:

4:classSingleton

5:{

6:private:

7://私有静态成员变量,引用所需的对象

8:staticSingletons;

9:inti;//数据

10:

11:Singleton(intx);

12:

13://将赋值操作符及拷贝构造函数都设置成私有的

14://且故意不实现,因为它们更本不会被调用

15://声明为私有的,以防止任何此类复制的动作产生

16:Singleton&operator=(Singleton&);

17:Singleton(constSingleton&);

18:

19:public:

20://静态方法,创建Singleton实例的惟一方法

21:staticSingleton&getInstance();

22://存取数据操作

23:intgetSingletonData();

24:voidsetSingletonData(intx);

25:};

1://Singleton.cpp

2:#include"Singleton.h"

3:#include

4:

5://静态成员数据初始化

6:SingletonSingleton::s(10);

7:

8:Singleton::Singleton(intx):i(x)

9:{

10:std::cout<<"Singleton()..."<<std::endl;

11:}

12:

13:Singleton&Singleton::getInstance()

14:{

15:std::cout<<"TheonlywaytoinstanceSingleton!"<<std::endl;

16:returns;

17:}

18:intSingleton::getSingletonData()

19:{

20:std::cout<<"getSingletonData()i="<<i<<std::endl;

21:returni;

22:}

23:voidSingleton::setSingletonData(intx)

24:{

25:std::cout<<"setSingletonData()i="<<x<<std::endl;

26:i=x;

27:}

1://test.cpp

2:

3:#include"Singleton.h"

4:#include

5:

6:intmain()

7:{

8:Singleton&s=Singleton::getInstance();

9:std::cout<<"Singleton::i="<<s.getSingletonData()<<std::endl;

10:

11:Singleton&s2=Singleton::getInstance();

12:s2.setSingletonData(20);

13:std::cout<<"NowSingleton::i="<<s.getSingletonData()<<std::endl;

14:

15:returnEXIT_SUCCESS;

16:}

1://如下典型的格式来自DouglasC.Schmidt

2://和TimHarrison的论文Double-CheckedLocking

3:classSingleton

4:{

5:public:

6:staticSingleton*instance(void)

7:{

8://Firstcheck

9:if(instance_==0)

10:{

11://Ensureserialization(guard

12://constructoracquireslock_).

13:Guardguard(lock_);

14://Doublecheck.

15:if(instance_==0)

16:instance_=newSingleton;

17:}

18:returninstance_;

19://guarddestructorreleaseslock_.

20:}

21:private:

22:staticMutexlock_;

23:staticSingleton*instance_;

24:};

//C++中,可以使用volatile关键字,其中对于VC++,2005及之后的版本才可以.

1://ScottMeyers指出,单独将pInstance声明为volatile

2://是不安全的,更安全的形式如下:

3:classSingleton{

4:public:

5:staticvolatileSingleton*volatileinstance();

6://else...

7:

8:private:

9://onemorevolatileadded

10:staticvolatileSingleton*volatilepInstance;

11:};

12:

13://fromtheimplementationfile

14:volatileSingleton*volatileSingleton::pInstance=0;

15:

16:volatileSingleton*volatileSingleton::instance()

17:{

18:if(pInstance==0)

19:{

20://Locklock;根据具体的库实现

21:Locklock;

22:if(pInstance==0)

23:{

24://onemorevolatileadded

25:

26:volatileSingleton*volatiletemp=

27:newvolatileSingleton;

28:pInstance=temp;

29:}

30:}

31:returnpInstance;

32:}

1://使用boost库,典型的可能如下--(不了解boost库)

2:staticSingleton*getInstDC()

3:{

4:if(inst_==0)

5:{

6:boost::mutex::scoped_lockl(guard_);

7:if(inst_==0){

8:inst_=newSingleton();

9:}

10:

11:returninst_;

12:}

13:}

1://使用boost库,另有人给出的可能实现方法如下:

2:template

3:classCMTSingleton

4:{

5:private:

6:classCreator

7:{

8:public:

9:Creator()

10:{

11:CMTSingleton<_tp>::instance();

12:}

13:inlinevoidDoNothing()const{}

14:}

15:

16:staticCreatorcreator;

17:};

18:

19:template

20:typenameCMTSingleton<_tp>::CreatorCMTSingleton<_tp>::creator;

1://Double-CheckedLocking实现：

2://同步类：

3://synobj.h

4:

5:#ifndefSYNOBJ_H

6:#defineSYNOBJ_H

7:

8:#include

9:

10://用宏将赋值和拷贝构造函数设为私有且不实现

11:#defineCLASS_UNCOPYABLE(classname)/

12:private:/

13:classname##(constclassname##&);/

14:classname##&operator=(constclassname##&);

15:

16:classMutex{

17:CLASS_UNCOPYABLE(Mutex)

18:

19:public:

20:Mutex():_cs()

21:{

22:InitializeCriticalSection(&_cs);

23:}

24:~Mutex()

25:{

26:DeleteCriticalSection(&_cs);

27:}

28:voidlock()

29:{

30:EnterCriticalSection(&_cs);

31:}

32:voidunlock()

33:{

34:LeaveCriticalSection(&_cs);

35:}

36:

37:private:

38:CRITICAL_SECTION_cs;//临界区

39:};

40:

41:classLock

42:{

43:CLASS_UNCOPYABLE(Lock)

44:

45:public:

46://explicit,可以阻止隐式转换的发生

47:explicitLock(Mutex&cs):_cs(cs)

48:{

49:_cs.lock();

50:}

51:

52:~Lock()

53:{

54:_cs.unlock();

55:}

56:

57:private:

58:Mutex&_cs;//互斥变量

59:};

60:

61:#endif/*SYNOBJ_H*/

1://有了同步对象很容易就能够写出如下代码：

2://singleton.h

3:

4:#ifndefSINGLETON_H

5:#defineSINGLETON_H

6:

7:#include"synobj.h"

8:

9:classSingleton

10:{

11:public:

12:staticvolatileSingleton*Instance()

13:{

14://Uniquepointofaccess

15:if(0==_instance)

16:{

17://因为lock只对0==_instance为true才有效

18://所以为了优化就再加入了一个判断。

19:Locklock(_mutex);

20:if(0==_instance)

21:{

22:_instance=newSingleton();

23:atexit(Destroy);

24://RegisterDestroyfunction

25:}

26:

27:}

28:

29:return_instance;

30:}

31:

32:voidDoSomething(){}

33:

34:private:

35:staticvoidDestroy()

36:{

37://Destroytheonlyinstance

38:if(_instance!=0)

39:{

40:delete_instance;

41:_instance=0;

42:}

43:}

44:Singleton(){}//PreventclientsfromcreatinganewSingleton

45:~Singleton(){}//PreventclientsfromdeletingaSingleton

46:Singleton(constSingleton&);//PreventclientsfromcopyingaSingleton

47:Singleton&operator=(constSingleton&);

48:

49:private:

50:staticMutex_mutex;

51:staticSingletonvolatile*_instance;//Theoneandonlyinstance

52:

53://为了防止编译器优化加入volatile这个修饰关键字

54:};

55:

56:#endif/*SINGLETON_H*/

1://singleton.cpp

2:

3:#include"singleton.h"

4:

5:MutexSingleton::_mutex;

6:

7://为了防止编译器优化加入volatile这个修饰关键字

8:volatileSingleton*Singleton::_instance=0;

1:publicclassUSTaxextendsTax

2:{

3:privatestaticUSTaxinstance;

4:privateUSTax(){}

5:publicstaticTaxgetInstance(){

6:if(instance==null){

7://检查到null之后同步,然后再检查一次,确保实例尚未创建

8:synchronied(this){

9:if(instance==null)

10:instance=newUSTax();

11:}

12:}

13:returninstance;

14:}

15:

16:privatesyschronizedstaticvoiddoSync(){

17:if(instance==null)

18:instance=newUSTax();

19:}

20:};

1:publicclassUSTaxextendsTax

2:{

3:privatestaticclassInstance{

4:staticfinalTaxinstance=newUSTax();

5:}

6:privatestaticUSTaxinstance;

7:privateUSTax(){}

8:publicstaticTaxgetInstance(){

9:returnInstance.instance;

10:}

11:};