C++设计模式——单件模式Singleton-Pattern

动机（Motivation）

• 在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂；而且有时候支持不使用的算法也是一个性能负担。
• 如何在运行时根据需要透明地更改对象的算法？将算法与对象本身解耦，从而避免上述问题？

模式定义

定义一系列算法，把它们一个个封装起来，并且使它们可互相替换（变化）。该模式使得算法可独立于使用它的客户程序(稳定)而变化（扩展，子类化）。 ——《设计模式》 GoF

结构（Structure）

模式举例

//解决性能问题，一次只创建一个对象

class Singleton{
private:
    Singleton();
    Singleton(const Singleton& other);//构造函数、拷贝构造函数私有化
public:
    static Singleton* getInstance();
    static Singleton* m_instance;
};

Singleton* Singleton::m_instance=nullptr;

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


//线程安全版本，但锁的代价过高
//加入对象已经创建，不是nullptr，对读操作的线程没有必要加锁，高并发会出问题
Singleton* Singleton::getInstance() {
    Lock lock;
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}



//双检查锁，但由于内存读写reorder不安全
// Double-Checked Locking
// 锁前检查一次，锁后检查一次
Singleton* Singleton::getInstance() {
    
    if(m_instance==nullptr){
        Lock lock;
        if (m_instance == nullptr) {
            m_instance = new Singleton();
            //正常顺序：先分配内存，再调用构造器，最后返回内存地址
            //编译器reorder优化有可能会改变顺序，先分配内存，再返回内存地址，最后调用构造器
            //这是出现的线程B拿到的对象内存没有调用构造器，出现了问题
            //
        }
    }
    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;
}

要点总结

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

基本代码

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // 将构造函数设为私有，禁止外界调用
public:
    static Singleton* GetInstance() {  // 获取实例的唯一全局访问点
        if (instance == NULL) {
            instance  = new Singleton();
        } 
        return instance;
    }
};

1. 保证唯一的实例；
2. 可以严格控制客户怎样访问实例以及何时访问，即对唯一实例的受控访问。