三种单例模式的C++实现

在Java中，经常会用到单例模式，所谓的单例模式，即是只能返回一个对象的实例，在面试中一般情况下，都会做相关的试题。

本文用c++实现单例模式，与java开发有一定的相关性，共享。

本文转载:http://blog.csdn.net/silangquan/article/details/20383653

目录(?) [-]

 简介
  1、懒汉式
  2、饿汉式
  3、多线程下的单例模式
  4、参考

简介：

      因为在设计或开发中，肯定会遇到这么一个情况，一个类只能有一个对象被创建，如果有多个对象的话，可能会导致状态的混乱和不一致。这种情况下，单例模式是最恰当的解决办法。它有很多的实现方法，各自的特性不相同，使用的情形也不相同。

      这里讲的是最常见的三种，分别是饿汉式、懒汉式和多线程式。

      通过单例模式，可以做到：

1、确保一个类只有一个实例被创建

2、提供了一个对象的全局访问指针

3、在不影响单例类的客户端的情况下允许有多个实例

懒汉式

       懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾明思议，配置的实例知道用到的时候才会加载..

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

GetInstance()使用懒惰初始化，也就是说它的返回值是当这个函数首次被访问时被创建的。这是一个防弹设计----所有GetInstance()之后的调用都返回相同实例的指针：

CSingleton* p1 = CSingleton::GetInstance();

CSingleton* p2 = p1->GetInstance)(;

CSingleton& ref = *CSginleton::GetInstance();

对于GetInstance稍加修改，这个设计模板可以适用于可变多实力情况，如一个类允许最多五个实例。

代码很简单，但是会存在内存泄漏的问题，new出来的东西始终没有释放，下面是一种饿汉式的一种改进。

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

在程序运行结束时，系统会调用CSingleton的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。使用这种方法释放单例对象有一些特征:

1、在单例类内部定义专门的嵌套类

2、在单例类内定义私有的专门用于释放的静态程序员

3、利用程序在结束时析构全局变量的特性，选择最终的释放时机

饿汉式

      饿汉式的特点是一开始就加载，如果说懒汉式是”时间换空间“，那么饿汉式就是“空间换时间”，因为一开始就创建实例，所以每次用到的之后直接返回就好啦。

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

    饿汉式是线程安全的，在类创建的同时就已经穿件号一个静态的对象供系统使用，以后不再改变，懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的。

   注：线程安全的通俗解释 -- 不管多个线程是怎样的执行顺序和优先级，或是wait,sleep,join等控制方式，如果一个类在多线程访问下运转一切正常，并且访问类不需要进行额外的同步处理和协调，那么我们就认为他是线程安全的。线程安全的类应该封转了所有必要的同步操作，调用者无需额外的同步，还有一点，无状态的类永远的线程安全的。

   在懒汉式的单例类中，其实有两个状态，单例未初始化和单例已经初始化。假设单例还未初始化，有两个线程同时调用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来保证thread safety.但是如果处理大量数据时，该锁才成为严重的性能瓶颈。