C++的三种单例模式-----深度解析

小编想要对三种的单例模式做下解析

简介

        因为在设计或开发中，肯定会有这么一种情况，一个类只能有一个对象被创建，如果有多个对象的话，可能会导致状态的混乱和不一致。这种情况下，单例模式是最恰当的解决办法。它有很多种实现方式，各自的特性不相同，使用的情形也不相同。今天要实现的是常用的三种，分别是饿汉式、懒汉式和多线程式。这个分类有点不准确，也可以说成 两类，懒汉式，饿汉式，然后要保证二者的线程安全。

        通过单例模式， 可以做到：确保一个类只有一个实例被建立 ，也就是C++中定义全局的东西的一个通用做法。

        在实现单例的过程中要注意如下问题：

• 构造函数应该声明为非公有，从而禁止外界创建实例。

• 拷贝操作和移动操作也应该禁止。（这个我在下面的代码示例中，没有写出来，大家自己写项目代码的时候，要做这个操作）

• 只能通过 Singleton 的公有特定类操作访问它的唯一实例（C++中的一个公有静态成员函数）。

懒汉式

      懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的时候才会加载。。。。。。

class CSingleton  
{  
public:  
static CSingleton* GetInstance()  
{  
     if ( m_pInstance == NULL )    
         m_pInstance = new CSingleton();  
     return m_pInstance;  
}  
private:  
    CSingleton(){};  
    static CSingleton * m_pInstance;  
};

GetInstance()使用懒惰初始化，也就是说它的返回值是当这个函数首次被访问时被创建的。​​​​​​​

饿汉式

       饿汉式的特点是一开始就加载了，如果说懒汉式是“时间换空间”，那么饿汉式就是“空间换时间”，因为一开始就创建了实例，所以每次用到的之后直接返回就好了。饿汉式有两种常见的写法，写法1和写法2

写法1：如下面这样，c98下是有问题的（在c98下是线程不安全的，在c11下是线程安全的）

class CSingleton    
{    
private:    
    CSingleton()      
    {    
    }    
public:    
    static CSingleton * GetInstance()    
    {    
        static CSingleton instance;     
        return &instance;    
    }    
};    

这种写法不是线程安全的(在c98中,但是在c11中没有问题，后面会再介绍c11)，因为静态的局部变量是在调用的时候分配到静态存储区，所以在编译的时候没有分配，

静态局部对象：
在程序执行到该对象的定义处时，创建对象并调用相应的构造函数！
如果在定义对象时没有提供初始指，则会暗中调用默认构造函数，如果没有默认构造函数，则自动初始化为0。
如果在定义对象时提供了初始值，则会暗中调用类型匹配的带参的构造函数（包括拷贝构造函数），如果没有定义这样的构造函数，编译器可能报错！
直到main（）结束后才会调用析构函数！

c11下这种写法是没有问题的，但是C98下，是不行的。

C++11起，Singleton 最佳实现是静态局部对象的方法，该方法是线程安全的。C++11标准保证：如果多个线程试图同时初始化同一静态局部对象，则初始化严格只发生一次。见《C++ Concurrency in Action》Second Edition，Chapter 3.3.1，或者见 Static local variables - cppreference.com :

If multiple threads attempt to initialize the same static local variable concurrently, the initialization occurs exactly once.

c98下 正确的写法应该像下面这样。

class CMsBsGPSInfoStart
{
public:
	static CMsBsGPSInfoStart& GetInstance();
protected:

	CMsBsGPSInfoStart();
	~CMsBsGPSInfoStart();

private:
	static CMsBsGPSInfoStart _instance;
private:
	//CLock m_lkMsBsGPSInfoStartFlag;
	bool m_bMsBsGPSInfoStartFlag;    //

public:
	bool GetMsBsGPSInfoStart();
	bool SetMsBsGPSInfoStart(bool bIsStart);
};
CMsBsGPSInfoStart CMsBsGPSInfoStart::_instance;
CMsBsGPSInfoStart::CMsBsGPSInfoStart() : m_bMsBsGPSInfoStartFlag(false)
{
	std::cout << "enter CMsBsGPSInfoStart::CMsBsGPSInfoStart() " << endl;
}

CMsBsGPSInfoStart::~CMsBsGPSInfoStart()
{
	std::cout << "enter CMsBsGPSInfoStart::~CMsBsGPSInfoStart() " << endl;
}

CMsBsGPSInfoStart& CMsBsGPSInfoStart::GetInstance()
{
	std::cout << "CMsBsGPSInfoStart::GetInstance()" << endl;
	return _instance;
}
bool CMsBsGPSInfoStart::SetMsBsGPSInfoStart(bool bIsStart)
{
	m_bMsBsGPSInfoStartFlag = bIsStart;
	return true;
}

我在主函数中包含头文件 instancetest.h后，主函数里什么也没有做

#include"instancetest.h"
using namespace::std;
int main()
{
	return 0;
}

直接生成exe进行调试

调试结果如下，这就证明在没有调用Getinstance的时候已经执行了构造函数。：

深入的理解下懒汉和饿汉

其实就是看定义的事静态成员对象变量还是静态成员对象指针变量，因为如果定义了静态成员对象变量，程序在运行之初已经分配了空间，就要调用构造函数了，而你在调用getinstance的时候，不会再调用构造函数了，因为之前已经调用过了，你就是用的现成的，就是所谓的饿汉模式，上来先把吃的准备好了，因为饿怕了，怕后期准备会挨饿。

而定义了静态成员对象指针变量，程序运行之初也会分配空间，但是那个是指针的空间，而不是对象的空间，所以不会调用对象的构造函数，而只有调用getinstance进行new操作的时候，才会对其调用构造函数，就是现上轿现扎耳朵眼，比较懒惰，所以叫懒汉模式。

懒汉式存在的问题：

在懒汉式的单例类中，其实有两个状态，单例未初始化和单例已经初始化。假设单例还未初始化，有两个线程同时调用GetInstance方法，这时执行 m_pInstance == NULL 肯定为真，然后两个线程都初始化一个单例，最后得到的指针并不是指向同一个地方，不满足单例类的定义了，所以懒汉式的写法会出现线程安全的问题！在多线程环境下，要对其进行修改。

多线程下的懒汉单例模式

     这里要处理的是懒汉模式。

class Singleton  
{  
private:  
    static Singleton* m_instance;  
    Singleton(){}  
public:  
    static Singleton* getInstance();  
};  
  
Singleton* Singleton::getInstance()  
{  
    if(NULL == m_instance)  
    {  
        Lock();//借用其它类来实现，如boost  
        if(NULL == m_instance)  
        {  
            m_instance = new Singleton;  
        }  
        UnLock();  
    }  
    return m_instance;  
}  

使用double-check来保证不会每次进来都去获取锁，来提高性能，先判断不为空的话，直接返回了数据。

恶汉模式的测试代码如下，大致代码如下：

class sun :public son
{
	public:
		~sun()
		{
			std::cout << "sun::~sun()";
		}
	public:
		static sun * GetInstance();
	private:
		sun(int a, int b, int c, double m, int d);
		static sun * m_instance;

};
#include"instance.h"
sun * sun::m_instance(NULL);

sun::sun(int a, int b, int c, double m, int d) :son(a, b, c, m, d)
{
	std::cout << "sun::sun"<<endl;
}
sun * sun::GetInstance()
{
	if (NULL == m_instance)
	{
		m_instance = new sun(5,6,7,8.2,10);
	}
	return m_instance;
}

然后主函数如下：

#include"instance.h"
//#include"instancetest.h"
using namespace::std;
int main()
{
	sun * test = sun::GetInstance();
	return 0;
}

运行结果如下所示：

这就是懒汉模式，用到的时候，才去调用，然后才会进行构造函数的调用，该模式下是线程不安全的。