详解单例模式

定义

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

版本一

class Singleton
{
public: static Singleton * GetInstance()
    {
        if (_instance == nullptr)
        {
            _instance = new Singleton();
        }
        return _instance;
    }

private: Singleton() {}
    //构造
    ~Singleton() 
    { 
        /* 释放其他资源，如果有的话 */ 
    }
    Singleton(const Singleton &clone)
    {

    } //拷贝构造
    Singleton& operator=(const Singleton&) {}
    static Singleton * _instance;
};

Singleton* Singleton::_instance = nullptr; //静态成员需要初始化

构造，拷贝构造，析构，赋值运算符私有化 是为了防止其他地方对单例进行实例化

版本一有两个问题：

        1.资源释放的问题，由于_instance的内存在全局内存空间，会在进程消亡时候进行释放，当其指向的内存空间是通过new 申请的，如果没有delete，析构是不会调用，从而内存或其他资源是没有时机进行释放的

        2.存在线程安全，如果在多线程下，两个或多个都走完if (_instance == nullptr)时候，交出cpu使用权，那么会倒是一个进程中有多个单例的实例

版本二

class Singleton
{
public:
    static Singleton * GetInstance()
    {
        if (_instance == nullptr)
        {
            _instance = new Singleton();
            atexit(Destructor);
        }
        return _instance;
    }

private:
    static void Destructor()
    {
        if (nullptr != _instance)
        {
            delete _instance;
            _instance = nullptr;
        }
    }Singleton();
    //构造
    ~Singleton() {}
    Singleton(const Singleton &cpy);
    //拷贝构造
    Singleton& operator=(const Singleton& other) {}
    static Singleton * _instance;
};

Singleton* Singleton::_instance = nullptr;//静态成员需要初始化

当程序正常终止时，将自动调用atexit()指向的函数，而无需使用参数，该版本解决了资源释放的问题

版本三

#include <mutex>
class Singleton
{
    // 懒汉模式 lazy load
public:
    static Singleton * GetInstance()
    {
        // std::lock_guard<std::mutex> lock(_mutex); // 3.1 切换线程
        // 如果在这里加锁，锁的粒度有点大，会导致效率问题
        if (_instance == nullptr)
        {
            std::lock_guard<std::mutex> lock(_mutex); // 3.2
            if (_instance == nullptr)
            {
                _instance = new Singleton(); // 1. 分配内存 // 2. 调用构造函数 // 3. 返回指针 // 多线程环境下 cpu reorder操作
                atexit(Destructor);
            }
        }return _instance;
    }
private:
    static void Destructor()
    {
        if (nullptr != _instance)
        {
            delete _instance;
            _instance = nullptr;
        }
    }
    Singleton(){} //构造
    Singleton(const Singleton &cpy){} //拷贝构造
    Singleton& operator=(const Singleton&) {}
    static Singleton * _instance;
    static std::mutex _mutex;
};

Singleton* Singleton::_instance = nullptr;//静态成员需要初始化 std::mutex Singleton::_mutex; //互斥锁初始化

版本三解决了多线程的安全问题，但是版本三还是有问题，因为在new Singleton()操作的时候，可能会出现cpu优化指令的情况，new分为三步1. 分配内存。  2. 调用构造函数。 3. 返回指针。  

cpu reorder操作的时候，可能会出现先执行1和3，在执行2，此时如果多线程模式下，如果线程A执行了1和3，此时交出cpu执行权，线程B拿到执行权，使用单例时候，发现内存已分配，会直接使用，但此时构造函数还没有执行，导致内存没有正确的初始化，会出现偶现bug

版本四

// volitile 
#include <mutex> 
#include <atomic> 
class Singleton 
{ 
public: 
    static Singleton * GetInstance() 
    { 
        Singleton* tmp = _instance.load(std::memory_order_relaxed);
        std::atomic_thread_fence(std::memory_order_acquire);//获取内存屏障 
        if (tmp == nullptr) 
        { 
            std::lock_guard<std::mutex> lock(_mutex); 
            tmp = _instance.load(std::memory_order_relaxed); 
            if (tmp == nullptr) 
            { 
                tmp = new Singleton;
                std::atomic_thread_fence(std::memory_order_release);//释放内 存屏障 
                _instance.store(tmp, std::memory_order_relaxed); 
                atexit(Destructor); } 
        }
        return tmp; 
    } 
private: 
    static void Destructor() 
    { 
        Singleton* tmp = _instance.load(std::memory_order_relaxed); 
        if (nullptr != tmp) 
        { 
            delete tmp; 
        } 
    }
    Singleton(){} 
    Singleton(const Singleton&) {} 
    Singleton& operator=(const Singleton&) {} 
    static std::atomic<Singleton*> _instance; 
    static std::mutex _mutex; 
};

std::atomic<Singleton*> Singleton::_instance;//静态成员需要初始化 
std::mutex Singleton::_mutex; //互斥锁初始化 
// g++ Singleton.cpp -o singleton -std=c++11

这里利用的C++11的特性，来保证解决内存排序的问题

版本五

// c++11 magic static 特性：如果当变量在初始化的时候，并发同时进⼊声明语句，并发线程将 会阻塞等待初始化结束。 
// c++ effective 
class Singleton 
{
public: 
    static Singleton& GetInstance() 
    { 
        static Singleton instance; 
        return instance; 
    } 
private: 
    Singleton(){} ~Singleton() {} 
    Singleton(const Singleton&) {} 
    Singleton& operator=(const Singleton&) {} 
};
// 继承 Singleton 
// g++ Singleton.cpp -o singleton -std=c++11 
/*该版本具备 版本5 所有优点： 
 * 1. 利用静态局部变量特性，延迟加载； 
 * 2. 利用静态局部变量特性，系统自动回收内存，自动调用析构函数； 
 * 3. 静态局部变量初始化时，没有 new 操作带来的cpu指令reorder操作； 
 * 4. c++11 静态局部变量初始化时，具备线程安全； */

版本五同时解决了上面的三个问题，而且写法简单，但缺点是无法扩展，比如需要多个单例的时候，要写多个单例类

版本六

template<typename T> 
class Singleton 
{ 
public: 
    static T& GetInstance() { 
        static T instance; // 这⾥要初始化DesignPattern，需要调⽤DesignPattern 构造函数，同时会调⽤⽗类的构造函数。 
        return instance; 
    } 

protected: 
    virtual ~Singleton() {} 
    Singleton() {} // protected修饰构造函数，才能让别⼈继承 
    Singleton(const Singleton&) {} 
    Singleton& operator =(const Singleton&) {} 
};

class DesignPattern : public Singleton<DesignPattern> 
{ 
    friend class Singleton<DesignPattern>; // friend 能让Singleton<T> 访问到 DesignPattern构造函数 
public: ~DesignPattern() {} 

private: 
    DesignPattern() {} 
    DesignPattern(const DesignPattern&) {} 
    DesignPattern& operator=(const DesignPattern&) {} 
};

版本六通过模板的方式，解决了版本五无法扩展的问题