设计模式之单例模式（C++实现）

单例模式

你需要系统中只有唯一一个实例存在的类的全局变量的时候才使用单例。

实现要点：

1.私有构造函数
2.声明静态单例对象
3.构造单例之前要加锁

class Singleton{
private:
    Singleton();
    Singleton(const Singleton& other);
public:
    static Singleton* getInstance();
    static Singleton* m_instance;
};

Singleton* Singleton::m_instance=nullptr;

//线程非安全版本  （单线程可行）
Singleton* Singleton::getInstance() {
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}

上述实现在单线程模式下是安全的，但是在多线程的情形下是非安全的，如线程A和线程B可能同时来到  if (m_instance == nullptr)  之后，构造之前，导致构造两次。

考虑加锁，改进如下：

//线程安全版本，但锁的代价过高
Singleton* Singleton::getInstance() {
    Lock lock;
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}

这种情况下，会导致锁的代价过高。如：有多个读线程到来，判断为 !nullptr 后可直接得返回值，但是这么做，每次都须先加锁，代价过高。 

再改进版本：

//双检查锁，但由于内存读写reorder不安全
Singleton* Singleton::getInstance() {
    
    if(m_instance==nullptr){
        Lock lock;
        if (m_instance == nullptr) {
            m_instance = new Singleton();
        }
    }
    return m_instance;
}

这里就是著名的double check，第二次check不能省略。考虑：A和B都会进入第一次check之后，lock之前，不管谁先执行，后面那个只需等一会，也会执行下面的代码。

但是这里又会出现问题：考虑m_instance = new Singleton();

理想情况下，执行这句指令，三步走：（1）分配内存 （2）调用构造器（初始化那块内存） （3）将内存地址返回给m_instance

但是，真正执行时可能不这么做，可能会出现（1）->（3）->（2）的顺序，此时，若在调用构造器之前，有另一个线程来到，进入判断，此时为 !nullptr，直接返回的结果则是错误的。

改进如下：

//C++ 11版本之后的跨平台实现 (volatile)
std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;

Singleton* Singleton::getInstance() {
    Singleton* tmp = m_instance.load(std::memory_order_relaxed);
    std::atomic_thread_fence(std::memory_order_acquire);//获取内存fence
    if (tmp == nullptr) {
        std::lock_guard<std::mutex> lock(m_mutex);
        tmp = m_instance.load(std::memory_order_relaxed);
        if (tmp == nullptr) {
            tmp = new Singleton;
            std::atomic_thread_fence(std::memory_order_release);//释放内存fence
            m_instance.store(tmp, std::memory_order_relaxed);
        }
    }
    return tmp;
}