C++设计模式（一）- 单例模式Singleton

“对象性能模式”
面向对象很好的解决了很好地解决了“抽象”的问题，但是不可避免地要付出一定的代价。对于通常情况来讲，面向对象的成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理。
在软件系统中，通常有这样一些特殊的类，必须保挣他们在系统中只有一个实例，才能确保逻辑的正确性和良好的效率。
模式定义

保证一个类只有一个实例，并提供一个该实例的全局访问点。
-《设计模式》GOF

class Singleton{
private:
    Singleton(); //构造函数和拷贝构造函数要设置成私有的，避免外部使用。如果这里不写，编译器会默认生成公有的。
    Singleton(const Singleton& other);
public:
    static Singleton* getInstance();
    static Singleton* m_instance;
};

单例模式有四个版本，我在项目中只用到了第一种：

非线程安全版本
如果m_instance为空，当多个线程同时访问getInstance()方法时， 就会 new出多个。m_instance实例。比如threadA和threadB同时进入if分支，treadA创建一个实例，threadB也创建一个实例，分别返回不同的m_instance。

Singleton* Singleton::m_instance=nullptr;
Singleton* Singleton::getInstance() {
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}

线程安全版本 - 单检查锁-代价过高
getInstance()方法开头加锁的方法可以很好地防止多个线程同时进入if分支的问题，保证只有一个m_instance实例。但是锁的代价有点大，加锁的目的是为了避免当m_instance为空的时候，多个线程同时抢进if分支内。但是当，m_instance创建成功之后，后续都不需再创建，getInstance()方法实际只有一个读操作，读操作本身就是线程安全的，所以锁在这里就显得冗余。
缺点：
当m_instance已经被创建了，相当于对读操作加锁，加大了开销，也影响了线程的读取效率。

Singleton* Singleton::getInstance() {
    Lock lock;
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}

线程安全版本 - 双检查锁Double-Check-Lock-有风险
把锁加在if语句内部，可以屏蔽掉当m_instance已经创建完成之后的读取操作加锁的情况。加第二个if语句，是为了避免当多个线程同时进入外部的if语句之后且锁之前，重复创建m_instance实例的情况。例如，threadA和threadB同时进入外部的if分支，threadA率先加了锁，再次判断m_instance仍然为空，则执行创建动作，创建完成之后返回。threadA返回之后锁被释放，这时，threadB加上锁，并再次判断m_instance是否已经被创建，发现已经不是空了，则放弃创建实例，直接返回已有的实例。所以，如果不进行双重检查，则会出现这种错。
缺点：
但由于内存读写reorder不安全，会导致双监察锁失效。
默认顺序: 分配内存->调用构造器->给指针赋值
reorder（编译器处于优化目的肯能会这样做）之后很可能： 分配内存->给指针赋值->调用构造器
有可能出现的问题： 按照reorder之后的顺序，如果threadA率先抢进第二个if分支 执行到 分配内存->给指针赋值，还没来得及执行构造函数，这时候threadB进入该函数，会判第一个if语句不为空，则直接返回m_instance, 但是这时m_instance还没有被threadA构造完成，也就是说只有内存地址，并没有被构造完成，所以这个地址是和合法的。

Singleton* Singleton::getInstance() {
    
    if(m_instance==nullptr){
        Lock lock;
        if (m_instance == nullptr) {
            m_instance = new Singleton();
        }
    }
    return m_instance;
}

线程安全版本 - C++ 11版本之后的跨平台实现 (volatile)

std::atomic 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 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;
}

要点总结

Singleton模式中的实例构造器可以设置为protected以允许子类派生。Singleton模式一般不要支持拷贝构造函数和clone接口，因为这有可能导致多个对象实例，与Singleton模式的初衷违背。实现多线程环境下安全的Singleton，要注意对双监察锁的正确实现。