C++设计模式--单例模式详解（懒汉模式、饿汉模式、双重锁）

• 应用场景
• 一、单例模式是什么？
• 二、使用步骤
• • 1.UML图
  • 2.代码实现

单例模式（Singleton）是保证一个类仅有一个实例，并且要提供一个访问这个类的全局访问点（提供访问接口函数）。
它同全局变量不同的是，全局变量可以被多个类使用，但是它不能防止被实例化多个对象，而单例模式的类对象可以保证没有被其他实例可以被创建，并且它可以提供一个访问该实例的方法。

Singleton类，定义一个GetInstance操作，允许客户访问它的唯一实例。GetInstance是一个静态方法，主要是负责创建自己的唯一实例。

方法1：

#include 
using namespace std;

class Singleton
{
private:
	Singleton()
	{ 
		m_Test = 520; 
	}
	static Singleton *m_Instance;  // 这里必须是静态对象
	int m_Test;
	
public:
	static Singleton *GetInstance()
	{
		// 第一次调用GetInstance发现m_Instance是空指针的时候会先创建，这个唯一对象被创建
		// 接着后面再调用的话只是直接返回已创建的对象而已
		if (m_Instance == NULL )   
			m_Instance = new Singleton ();  
			
		return m_Instance;
	}

	// 释放对象
	static void ReleaseInstance()
	{
		if (m_Instance != NULL )
		{
			delete m_Instance;
			m_Instance = NULL ;
		}
	}

	// 提供类对象操作接口
	int GetTest()
	{
		return m_Test;
	}


};

// 静态类对象的初始化方式
Singleton *Singleton ::m_Instance = NULL;

int main(int argc , char *argv [])
{
	Singleton *pObj1= Singleton ::GetInstance();
	Singleton *pObj2= Singleton ::GetInstance();
	// 比较两次实例化后的对象的结果是实例相同
    if(pObj1 == pObj2)
    	printf("two obj is same....");
    	
	cout<GetTest()<GetTest()< 
方法1应该是我们平时最简单常见的方式，但是这个方式有个问题就是，如果是多线程使用的话，多个线程同时，注意是同时访问Singleton类，调用GetInstance()方法，会有可能造成创建多个实例的。
 
方法2：
 
#include 
using namespace std;

class Singleton
{
private:
	Singleton()
	{ 
		m_Test = 520; 
	}
	static Singleton *m_Instance;  // 这里必须是静态对象
	int m_Test;
	
public:
	static Singleton *GetInstance()
	{
        
        // 加锁处理多线程问题
		Lock(); // C++没有直接的Lock操作，请使用其它库的Lock，比如Boost，此处仅为了演示说明
		
		if (m_Instance == NULL )   
			m_Instance = new Singleton (); 
			 
		UnLock();
			
		return m_Instance;
	}

	
};

// 静态类对象的初始化方式
Singleton *Singleton ::m_Instance = NULL;


 
这里lock是确保当一个线程位于代码的临界区时，另一个线程不会进入临界区，如果其他线程试图进入锁定的代码，则它将一直等待，直到
 该对象被释放。
 
此处进行了两次m_Instance == NULL的判断，是借鉴了Java的单例模式实现时，使用的所谓的“双重锁定”机制。因为进行一次加锁和解锁是需要付出对应的代价的，而进行两次判断，就可以避免多次加锁与解锁操作，同时也保证了线程安全。如果进行大数据的操作，加锁操作将成为一个性能的瓶颈。
 
方法3：
 
#include 
using namespace std;

class Singleton
{
private:
	Singleton()
	{ 
		m_Test = 520; 
	}
	static Singleton *m_Instance;  // 这里必须是静态对象
	int m_Test;
	
public:
	static Singleton *GetInstance()
	{
        
 		return const_cast (m_Instance);
	}

	
};

// 静态类对象的初始化方式
const Singleton *Singleton ::m_Instance = new Singleton();


 
因为静态初始化在程序开始时，也就是进入主函数之前，由主线程以单线程方式完成了初始化，所以静态初始化实例保证了线程安全性。在性能要求比较高时，就可以使用这种方式，从而避免频繁的加锁和解锁造成的资源浪费。这种静态初始化的方式是在自己被加载时就将自己实例化，所以就被称之为饿汉式单例类，而原先方法1-2的处理方式是要在第一次被引用的时候，才会被自己实例化，所以我们也称之它为懒汉式单例类。
 上述三种实现，都要考虑到实例的销毁，以下两种可以针对实例销毁的方式。，
 
方法4：
 
#include 
using namespace std;

class Singleton
{
private:
	Singleton()
	{ 
		m_Test = 520; 
	}
	static Singleton *m_Instance;  // 这里必须是静态对象
	int m_Test;
	
public:
	static Singleton *GetInstance()
	{
		static Singleton m_Instance;
		return &m_Instance;
	}
};

 
因为静态类对象不是通过指针创建，所以自然没有对应的delete。但是大多时候，我们可能会在new完一个对象之后，就会可能会对它进行释放，那么有没有一种方式能让它自动销毁，类似智能指针的方式呢。看下一个实现方式。
 
方法5：
 
#include 
using namespace std;

class Singleton
{
public:
	static Singleton *GetInstance()
	{
		return m_Instance;
	}

	int GetTest()
	{
		return m_Test;
	}

private:
	Singleton()
	{ 
		m_Test = 520; 
	}
	static Singleton *m_Instance;
	int m_Test;

	//  创建释放类，用来自动销毁对象
	class GC
	{
	public :
		~GC()
		{
			// 释放类对象
			if (m_Instance != NULL )
			{
				cout<<"delete instance..." <