Singleton单例模式

模式定义

　　保证一个类只能生成一个实例对象。

单线程版本

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;
}

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

多线程版本

class Singleton{
private:
    // 私有化构造函数和拷贝构造函数
    Singleton();
    Singleton(const Singleton& other);
    mutex  mymutex;  //互斥量
public:
    // 静态对象指针和静态获取对象指针函数
    static Singleton* getInstance();
    static Singleton* m_instance;
};
// 初始化
Singleton* Singleton::m_instance=nullptr;    

线程安全版本，但锁的代价过高

//线程安全版本，但锁的代价过高
Singleton* Singleton::getInstance() {
    unique_lock<mutex> mylock(mymutex);
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}

双检查锁版本（会出错）

//双检查锁
// 但由于内存读写reorder不安全， 编译器的优化有关
// 在汇编层面m_instance = new Singleton()语句可能的执行顺序是
// 先分配内存地址，再执行构造函数，再赋值给内存，导致第二次检查结果为false，但是这时对象还没创建
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*> 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;
}

　　综上，在多线程中，推荐使用原子操作版。