单例模式

　　单例模式也称为单件模式、单子模式，可能是使用最广泛的设计模式。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的功能模块，如系统的日志输出，GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。
       单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显的很不优雅。 使用全局对象能够保证方便地访问实例，但是不能保证只声明一个对象——也就是说除了一个全局实例外，仍然能创建相同类的本地实例。
　　单例模式又分为饿汉式单例和懒汉式单例,饿汉式单例在单例类被加载时就实例化一个对象交给自己的引用;而懒汉式在调用取得实例方法的时候才会实例化对象

1. 懒汉式

对于拷贝构造和赋值操作符，如果我们不打算自定义的话,那么最好将它们也置为私有且不实现

/////////// lazy 非线程安全  ////////////////
class CSingleton
{
private:
    CSingleton(){}   //构造函数是私有的 // 最好将 copy construct 和 assignment 私有化
    static CSingleton* m_pInstance;
public:
    static CSingleton* GetInstance()
    {
        if (m_pInstance == 0)  //判断是否第一次调用
            m_pInstance = new CSingleton();
        return m_pInstance;
    }
};
CSingleton* CSingleton::m_pInstance = 0;

//////////////////线程安全的 懒汉式/////////////////////
#include <Windows.h>
class CAutoLock
{
private:
    CRITICAL_SECTION  m_cs;
public:
    CAutoLock()
    {
        InitializeCriticalSection(&m_cs);
        Lock();//如果是用的时候只定义锁对象，可以不手动进入临界区和退出临界区
    }
    ~CAutoLock()
    {
        UnLock();
        DeleteCriticalSection(&m_cs);
    }
    void Lock()
    {
        EnterCriticalSection(&m_cs);
    }
    void UnLock()
    {
        LeaveCriticalSection(&m_cs);
    }
};

class CSingleton
{
private:
    CSingleton(){};
    CSingleton(const CSingleton &);
    CSingleton& operator = (const CSingleton &);
    static CSingleton *m_pInstance;
    class CGarbo   //它的唯一工作就是在析构函数中删除CSingleton的实例
    {
    public:
        ~CGarbo(){ delete CSingleton::m_pInstance; }
    };
    static CGarbo Garbo;  //定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数
public:
    static CSingleton* GetInstance()
    {
        if (m_pInstance == NULL)
        {   //double check  
            CAutoLock lock; //用lock实现线程安全，用资源管理类，实现异常安全  
            //使用资源管理类，在抛出异常的时候，资源管理类对象会被析构，析构总是发生的无论是因为异常抛出还是语句块结束。  
            if (m_pInstance == NULL)
            {
                m_pInstance = new CSingleton;
            }
        }
        return m_pInstance;
    }
};
CSingleton* CSingleton::m_pInstance = 0;

 之所以在Instantialize函数里面对pInstance 是否为空做了两次判断，因为该方法调用一次就产生了对象，pInstance == NULL 大部分情况下都为false，如果按照原来的方法，每次获取实例都需要加锁，效率太低。而改进的方法只需要在第一次 调用的时候加锁，可大大提高效率。

 

2. 饿汉式

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

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

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

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

看看：https://zhuanlan.zhihu.com/p/37469260

 

Best of All:

C++11规定了local static在多线程条件下的初始化行为，要求编译器保证了内部静态变量的线程安全性。在C++11标准下，《Effective C++》提出了一种更优雅的单例模式实现，使用函数内的 local static 对象。这样，只有当第一次访问getInstance()方法时才创建实例。这种方法也被称为Meyers' Singleton。C++0x之后该实现是线程安全的，C++0x之前仍需加锁。

// version 1.2
class Singleton
{
private:
	Singleton() { };
	~Singleton() { };
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
public:
	static Singleton& getInstance() 
        {
		static Singleton instance;
		return instance;
	}
};

3. 饿汉版（Eager Singleton）

饿汉版（Eager Singleton）：指单例实例在程序运行时被立即执行初始化

// version 1.3
class Singleton
{
private:
	static Singleton instance;
private:
	Singleton();
	~Singleton();
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
public:
	static Singleton& getInstance() {
		return instance;
	}
}

// initialize defaultly
Singleton Singleton::instance;

由于在main函数之前初始化，所以没有线程安全的问题。但是潜在问题在于no-local static对象（函数外的static对象）在不同编译单元中的初始化顺序是未定义的。也即，static Singleton instance;和static Singleton& getInstance()二者的初始化顺序不确定，如果在初始化完成之前调用 getInstance() 方法会返回一个未定义的实例。

总结：

• Eager Singleton 虽然是线程安全的，但存在潜在问题；
• Lazy Singleton通常需要加锁来保证线程安全，但局部静态变量版本在C++11后是线程安全的；
• 局部静态变量版本（Meyers Singleton）最优雅。

另外Poco中实现单例

#include "Poco/SingletonHolder.h"
class MySingleton
{
public:
    MySingleton()
    {
        // ...
    }
    ~MySingleton()
    {
        // ...
    }
    // ...
    static MySingleton& instance()
    {
        static Poco::SingletonHolder<MySingleton> sh;
        return *sh.get();
    }
};

 

————————————————
参考链接：https://blog.csdn.net/silangquan/article/details/20383653
参考链接：https://blog.csdn.net/hackbuteer1/article/details/7460019