设计模式之单例

1、单例模式

保证一个类只有一个实例，提供一个访问它的全局访问点，使得系统中只有唯一的一个对象实例。应用：常用于管理资源，如日志、线程池

要点：

• 在类中，要构造一个实例，就必须调用类的构造函数，并且为了保证全局只有一个实例；
• 需防止在外部调用类的构造函数而构造实例，需要将构造函数的访问权限标记为private；
• 同时阻止拷贝创建对象时赋值时拷贝对象，因此也将它们声明并权限标记为private；
• 另外，需要提供一个全局访问点，就需要在类中定义一个static函数，返回在类内部唯一构造的实例。

class Singleton
{
	public:
		static Singleton& getInstance()
		{
			static Singleton instance;
			return instance;
		}
	private:
		Singleton() {}   //防止外部调用构造创建对象
		Singleton(Singleton const &singleton);//阻止拷贝创建对象
		Singleton& operator = (Singleton const &singleton);
		//阻止赋值对象
};
int main()
{
    Singleton &a = Singleton::getInstance();
    return 0;
}

优点：在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例；避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

2、饿汉单例模式

饿了肯定要饥不择食。所以在单例类定义的时候就进行实例化。在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。

//饿汉式：线程安全
class Singleton
{
public:
    static Singleton* getInstance();
    ~Singleton(){}

private:
   Singleton(){}                            //构造函数私有
   Singleton(const Singleton& obj) = delete;      //明确拒绝
   Singleton& operator=(const Singleton& obj) = delete; //明确拒绝
    
   static Singleton* m_pSingleton;
};

Singleton* Singleton::m_pSingleton = new Singleton();

Singleton* Singleton::getInstance()
{
    return m_pSingleton;
}

3、懒汉单例模式

在第一次用到类实例的时候才会去实例化一个对象；不会造成内存浪费，因为只有在被使用时才开始创建实例；在访问量较小，甚至可能不会去访问的情况下，采用懒汉实现，这是以时间换空间。

//懒汉式一般实现：getInstance返回的实例指针需要delete
class Singleton
{
public:
    static Singleton* getInstance();
    ~Singleton(){}

private:
    Singleton(){}                            //构造函数私有
    Singleton(const Singleton& obj) = delete;      //明确拒绝
    Singleton& operator=(const Singleton& obj) = delete; //明确拒绝
    
    static Singleton* m_pSingleton;
};
Singleton* Singleton::m_pSingleton = NULL;

线程安全
Singleton* Singleton::getInstance()
{
    if(m_pSingleton == NULL)
    {
        mt.lock();              //加锁
        if(m_pSingleton == NULL)
        {
            m_pSingleton = new Singleton();
        }
        return m_pSingleton;
        mt.unlock();
 }