单例模式的实现

定义

保证一个类仅有一个实例，并提供一个该实例的全局访问点。 —— 《设计模式》 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、不支持多线程，2、_instance指向的对象没有释放。然后我们先来解决内存泄漏问题，版本二如下：

版本二

class Singleton {
public:
    static Singleton * GetInstance() {
        if (_instance == nullptr) {
            _instance = new Singleton();
            atexit(Destructor);
        }
        return _instance;
    }
    ~Singleton() {}
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;//静态成员需要初始化

这时我们解决了资源释放的问题，还没有解决多线程问题，接下来我们解决多线程的问题，版本三如下：

版本三

#include <mutex>
class Singleton { 
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();
                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; //互斥锁初始化

版本三还存在问题没？主要是还没有考虑到CPU的reorder操作。所以我们用内存屏障来解决这个问题，版本四如下：

版本四

#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; //互斥锁初始化

接下来，我们来学习一下c++ effective里面提供的一个版本，版本五如下：

版本五

class Singleton
{
public:
    static Singleton& GetInstance() {
        static Singleton instance;
        return instance;
    }
private:
    Singleton(){}
    ~Singleton() {}
    Singleton(const Singleton&) {}
    Singleton& operator=(const Singleton&) {}
};

该版本简洁的难以置信，大牛就是大牛，作者巧妙应用了c++11 magic static 特性：如果当变量在初始化的时候，并发同时进 入声明语句，并发线程将会阻塞等待初始化结束，但是有一个缺点，如果项目里面有多个单例，就无法使用了。然后我们用模板和继承来实现一个更方便使用的版本，版本六如下：

版本六

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&) {}
};

总结

        通过从最简单的版本不停迭代，最后得到一个很不错的版本，具有以下优点：

        1. 利用静态局部变量特性，延迟加载；

        2. 利用静态局部变量特性，系统自动回收内存，自动调用析构函数；

        3. 静态局部变量初始化时，没有 new 操作带来的cpu指令reorder操作；

        4. c++11 静态局部变量初始化时，具备线程安全。

技术参考

1. 视频技术参考： https://ke.qq.com/course/417774?flowToken=1041367