Singleton单例模式和DoubleCheckedLocking双重检查锁定模式

问题描述

现在&＃xff0c;不管开发一个多大的系统&＃xff08;至少我现在的部门是这样的&＃xff09;&＃xff0c;都会带一个日志功能&＃xff1b;在实际开发过程中&＃xff0c;会专门有一个日志模块&＃xff0c;负责写日志&＃xff0c;由于在系统的任何地方&＃xff0c;我们都有可能要调用日志模块中的函数&＃xff0c;进行写日志。那么&＃xff0c;如何构造一个日志模块的实例呢&＃xff1f;难道&＃xff0c;每次new一个日志模块实例&＃xff0c;写完日志&＃xff0c;再delete&＃xff0c;不要告诉我你是这么干的。在C&＃43;&＃43;中&＃xff0c;可以构造一个日志模块的全局变量&＃xff0c;那么在任何地方就都可以用了&＃xff0c;是的&＃xff0c;不错。但是&＃xff0c;我所在的开发部门的C&＃43;&＃43;编码规范是参照Google的编码规范的。

全局变量在项目中是能不用就不用的&＃xff0c;它是一个定时炸弹&＃xff0c;是一个不安全隐患&＃xff0c;特别是在多线程程序中&＃xff0c;会有很多的不可预测性&＃xff1b;同时&＃xff0c;使用全局变量&＃xff0c;也不符合面向对象的封装原则&＃xff0c;所以&＃xff0c;在纯面向对象的语言Java和C#中&＃xff0c;就没有纯粹的全局变量。那么&＃xff0c;如何完美的解决这个日志问题&＃xff0c;就需要引入设计模式中的单例模式。

单例模式

何为单例模式&＃xff0c;在GOF的《设计模式&＃xff1a;可复用面向对象软件的基础》中是这样说的&＃xff1a;保证一个类只有一个实例&＃xff0c;并提供一个访问它的全局访问点。首先&＃xff0c;需要保证一个类只有一个实例&＃xff1b;在类中&＃xff0c;要构造一个实例&＃xff0c;就必须调用类的构造函数&＃xff0c;如此&＃xff0c;为了防止在外部调用类的构造函数而构造实例&＃xff0c;需要将构造函数的访问权限标记为protected或private&＃xff1b;最后&＃xff0c;需要提供要给全局访问点&＃xff0c;就需要在类中定义一个static函数&＃xff0c;返回在类内部唯一构造的实例。意思很明白&＃xff0c;使用UML类图表示如下。

UML类图

代码实现

单例模式&＃xff0c;单从UML类图上来说&＃xff0c;就一个类&＃xff0c;没有错综复杂的关系。但是&＃xff0c;在实际项目中&＃xff0c;使用代码实现时&＃xff0c;还是需要考虑很多方面的。

#include
using namespace std;class Singleton
{
public: static Singleton *GetInstance() { if (m_Instance &＃61;&＃61; NULL ) { m_Instance &＃61; new Singleton (); } return m_Instance; } static void DestoryInstance() { if (m_Instance !&＃61; NULL ) { delete m_Instance; m_Instance &＃61; NULL ; } } // This is just a operation example int GetTest() { return m_Test; } private: Singleton(){ m_Test &＃61; 10; } static Singleton *m_Instance; int m_Test; }; Singleton *Singleton ::m_Instance &＃61; NULL; int main(int argc , char *argv []) { Singleton *singletonObj &＃61; Singleton ::GetInstance(); cout<GetTest()<<endl; Singleton ::DestoryInstance(); return 0; }

这是最简单&＃xff0c;也是最普遍的实现方式&＃xff0c;也是现在网上各个博客中记述的实现方式&＃xff0c;但是&＃xff0c;这种实现方式&＃xff0c;有很多问题&＃xff0c;比如&＃xff1a;没有考虑到多线程的问题&＃xff0c;在多线程的情况下&＃xff0c;就可能创建多个Singleton实例&＃xff0c;以下版本是改善的版本。

实现二&＃xff1a;

#include
using namespace std;class Singleton
{
public: static Singleton *GetInstance() { if (m_Instance &＃61;&＃61; NULL ) { Lock(); // C&＃43;&＃43;没有直接的Lock操作&＃xff0c;请使用其它库的Lock&＃xff0c;比如Boost&＃xff0c;此处仅为了说明 if (m_Instance &＃61;&＃61; NULL ) { m_Instance &＃61; new Singleton (); } UnLock(); // C&＃43;&＃43;没有直接的Lock操作&＃xff0c;请使用其它库的Lock&＃xff0c;比如Boost&＃xff0c;此处仅为了说明 } return m_Instance; } static void DestoryInstance() { if (m_Instance !&＃61; NULL ) { delete m_Instance; m_Instance &＃61; NULL ; } } int GetTest() { return m_Test; } private: Singleton(){ m_Test &＃61; 0; } static Singleton *m_Instance; int m_Test; }; Singleton *Singleton ::m_Instance &＃61; NULL; int main(int argc , char *argv []) { Singleton *singletonObj &＃61; Singleton ::GetInstance(); cout<GetTest()<<endl; Singleton ::DestoryInstance(); return 0; }

此处进行了两次m_Instance &＃61;&＃61; NULL的判断&＃xff0c;是借鉴了Java的单例模式实现时&＃xff0c;使用的所谓的“双检锁”机制。因为进行一次加锁和解锁是需要付出对应的代价的&＃xff0c;而进行两次判断&＃xff0c;就可以避免多次加锁与解锁操作&＃xff0c;同时也保证了线程安全。但是&＃xff0c;这种实现方法在平时的项目开发中用的很好&＃xff0c;也没有什么问题&＃xff1f;但是&＃xff0c;如果进行大数据的操作&＃xff0c;加锁操作将成为一个性能的瓶颈&＃xff1b;为此&＃xff0c;一种新的单例模式的实现也就出现了。

实现三&＃xff1a;

#include
using namespace std;class Singleton
{
public: static Singleton *GetInstance() { return const_cast (m_Instance); } static void DestoryInstance() { if (m_Instance !&＃61; NULL ) { delete m_Instance; m_Instance &＃61; NULL ; } } int GetTest() { return m_Test; } private: Singleton(){ m_Test &＃61; 10; } static const Singleton *m_Instance; int m_Test; }; const Singleton *Singleton ::m_Instance &＃61; new Singleton(); int main(int argc , char *argv []) { Singleton *singletonObj &＃61; Singleton ::GetInstance(); cout<GetTest()<<endl; Singleton ::DestoryInstance(); }

因为静态初始化在程序开始时&＃xff0c;也就是进入主函数之前&＃xff0c;由主线程以单线程方式完成了初始化&＃xff0c;所以静态初始化实例保证了线程安全性。在性能要求比较高时&＃xff0c;就可以使用这种方式&＃xff0c;从而避免频繁的加锁和解锁造成的资源浪费。由于上述三种实现&＃xff0c;都要考虑到实例的销毁&＃xff0c;关于实例的销毁&＃xff0c;待会在分析。由此&＃xff0c;就出现了第四种实现方式&＃xff1a;

实现四&＃xff1a;

#include
using namespace std;class Singleton
{
public: static Singleton *GetInstance() { static Singleton m_Instance; return &m_Instance; } int GetTest() { return m_Test&＃43;&＃43;; } private: Singleton(){ m_Test &＃61; 10; }; int m_Test; }; int main(int argc , char *argv []) { Singleton *singletonObj &＃61; Singleton ::GetInstance(); cout<GetTest()<<endl; singletonObj &＃61; Singleton ::GetInstance(); cout<GetTest()<<endl; }

以上就是四种主流的单例模式的实现方式&＃xff0c;如果大家还有什么好的实现方式&＃xff0c;希望大家能推荐给我。谢谢了。

实例销毁

在上述的四种方法中&＃xff0c;除了第四种没有使用new操作符实例化对象以外&＃xff0c;其余三种都使用了&＃xff1b;我们一般的编程观念是&＃xff0c;new操作是需要和delete操作进行匹配的&＃xff1b;是的&＃xff0c;这种观念是正确的。在上述的实现中&＃xff0c;是添加了一个DestoryInstance的static函数&＃xff0c;这也是最简单&＃xff0c;最普通的处理方法了&＃xff1b;但是&＃xff0c;很多时候&＃xff0c;我们是很容易忘记调用DestoryInstance函数&＃xff0c;就像你忘记了调用delete操作一样。由于怕忘记delete操作&＃xff0c;所以就有了智能指针&＃xff1b;那么&＃xff0c;在单例模型中&＃xff0c;没有“智能单例”&＃xff0c;该怎么办&＃xff1f;怎么办&＃xff1f;

那我先从实际的项目中说起吧&＃xff0c;在实际项目中&＃xff0c;特别是客户端开发&＃xff0c;其实是不在乎这个实例的销毁的。因为&＃xff0c;全局就这么一个变量&＃xff0c;全局都要用&＃xff0c;它的生命周期伴随着软件的生命周期&＃xff0c;软件结束了&＃xff0c;它也就自然而然的结束了&＃xff0c;因为一个程序关闭之后&＃xff0c;它会释放它占用的内存资源的&＃xff0c;所以&＃xff0c;也就没有所谓的内存泄漏了。但是&＃xff0c;有以下情况&＃xff0c;是必须需要进行实例销毁的&＃xff1a;

1. 在类中&＃xff0c;有一些文件锁了&＃xff0c;文件句柄&＃xff0c;数据库连接等等&＃xff0c;这些随着程序的关闭而不会立即关闭的资源&＃xff0c;必须要在程序关闭前&＃xff0c;进行手动释放&＃xff1b;
2. 具有强迫症的程序员。

以上&＃xff0c;就是我总结的两点。

虽然&＃xff0c;在代码实现部分的第四种方法能满足第二个条件&＃xff0c;但是无法满足第一个条件。好了&＃xff0c;接下来&＃xff0c;就介绍一种方法&＃xff0c;这种方法也是我从网上学习而来的&＃xff0c;代码实现如下&＃xff1a;

#include
using namespace std;class Singleton
{
public: static Singleton *GetInstance() { return m_Instance; } int GetTest() { return m_Test; } private: Singleton(){ m_Test &＃61; 10; } static Singleton *m_Instance; int m_Test; // This is important class GC { public : ~GC() { // We can destory all the resouce here, eg:db connector, file handle and so on if (m_Instance !&＃61; NULL ) { cout<<"Here is the test" <<endl; delete m_Instance; m_Instance &＃61; NULL ; } } }; static GC gc; }; Singleton *Singleton ::m_Instance &＃61; new Singleton(); Singleton ::GC Singleton ::gc; int main(int argc , char *argv []) { Singleton *singletonObj &＃61; Singleton ::GetInstance(); cout<GetTest()<<endl; return 0; }

在程序运行结束时&＃xff0c;系统会调用Singleton的静态成员GC的析构函数&＃xff0c;该析构函数会进行资源的释放&＃xff0c;而这种资源的释放方式是在程序员“不知道”的情况下进行的&＃xff0c;而程序员不用特别的去关心&＃xff0c;使用单例模式的代码时&＃xff0c;不必关心资源的释放。那么这种实现方式的原理是什么呢&＃xff1f;我剖析问题时&＃xff0c;喜欢剖析到问题的根上去&＃xff0c;绝不糊涂的停留在表面。由于程序在结束的时候&＃xff0c;系统会自动析构所有的全局变量&＃xff0c;实际上&＃xff0c;系统也会析构所有类的静态成员变量&＃xff0c;就像这些静态变量是全局变量一样。我们知道&＃xff0c;静态变量和全局变量在内存中&＃xff0c;都是存储在静态存储区的&＃xff0c;所以在析构时&＃xff0c;是同等对待的。

由于此处使用了一个内部GC类&＃xff0c;而该类的作用就是用来释放资源&＃xff0c;而这种使用技巧在C&＃43;&＃43;中是广泛存在的&＃xff0c;在后面的博客中&＃xff0c;我会总结这一技巧&＃xff0c;参见《C&＃43;&＃43;中的RAII机制》。

模式扩展

在实际项目中&＃xff0c;一个模式不会像我们这里的代码那样简单&＃xff0c;只有在熟练了各种设计模式的特点&＃xff0c;才能更好的在实际项目中进行运用。单例模式和工厂模式在实际项目中经常见到&＃xff0c;两种模式的组合&＃xff0c;在项目中也是很常见的。所以&＃xff0c;有必要总结一下两种模式的结合使用。

一种产品&＃xff0c;在一个工厂中进行生产&＃xff0c;这是一个工厂模式的描述&＃xff1b;而只需要一个工厂&＃xff0c;就可以生产一种产品&＃xff0c;这是一个单例模式的描述。所以&＃xff0c;在实际中&＃xff0c;一种产品&＃xff0c;我们只需要一个工厂&＃xff0c;此时&＃xff0c;就需要工厂模式和单例模式的结合设计。由于单例模式提供对外一个全局的访问点&＃xff0c;所以&＃xff0c;我们就需要使用简单工厂模式中那样的方法&＃xff0c;定义一个标识&＃xff0c;用来标识要创建的是哪一个单件。由于模拟代码较多&＃xff0c;在文章最后&＃xff0c;提供下载链接。

总结

为了写这篇文章&＃xff0c;自己调查了很多方面的资料&＃xff0c;由于网上的资料在各方面都有很多的瑕疵&＃xff0c;质量参次不齐&＃xff0c;对我也造成了一定的误导。而这篇文章&＃xff0c;有我自己的理解&＃xff0c;如有错误&＃xff0c;请大家指正。

由于该文对设计模式的总结&＃xff0c;我认为比网上80%的都全面&＃xff0c;希望对大家有用。在实际的开发中&＃xff0c;并不会用到单例模式的这么多种&＃xff0c;每一种设计模式&＃xff0c;都应该在最适合的场合下使用&＃xff0c;在日后的项目中&＃xff0c;应做到有地放矢&＃xff0c;而不能为了使用设计模式而使用设计模式。