设计模式——单例模式(Singleton)

1. 单例模式

1.1 定义

单例模式：保证一个类仅有一个实例，并提供一个访问他的全局访问点。[DP]

通常我们可以定义一个全局变量使得对象被访问，但它不能防止你实例化多个对象。一个最好的方法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该类实例的方法。

1.2 单例模式结构图

1.3 分类

单例模式的实现分为懒汉式和饿汉式：

• 懒汉式：在类实例第一次被使用时才会将自己实例化。
• 饿汉式：在类被加载时就将自己实例化。

1.3 运用场景

运用场景举例如下：

1. 设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动；
2. 数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取。

2. 单例模式的实现

2.1 C++实现

2.1.1 基础要点

• 全局只有一个实例。
• 线程安全
• 禁止赋值和拷贝
• 用户通过接口获取实例

2.1.2 懒汉式

class Singleton
{
private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton* GetInstance()
    {
        if (m_pInstance == nullptr)
        {
            m_pInstance = new Singleton;
        }
        return m_pInstance;
    }
private:
    static Singleton* m_pInstance;
};

Singleton* Singleton::m_pInstance = nullptr;

上述懒汉式模式存在的问题：

• 线程安全问题：上述代码在单线程下工作是没有问题的，但是，在多线程时获取单例对象可能引发竞争条件：第一个线程判断m_pInstance为空，则开始实例化对象，与此同时，第二个线程也获取单例对象，判断m_pInstance也为空，则实例出多个单例对象。
• 内存泄漏：由于单例对象由类自身进行管理，外部不会delete m_pInstance。导致只new，没有delete。另一种情况，若多线程中，同时new了多个对象，最终m_pInstance指向其中一个，导致其他对象指针成为野指针。

针对上述问题，第一条我们可以通过加锁解决，第二条我们可以通过使用智能指针来解决。因此有了以下实现。

#include <memory>
#include <mutex>

class Singleton
{
private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static std::shared_ptr<Singleton> GetInstance()
    {
    	//双检锁，第一次判断防止每次进入函数都加锁带来的性能开销
    	//第二次判断，防止多线程程序多次创建实例
        if (m_pInstance == nullptr)
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            if (m_pInstance == nullptr)
            {
                m_pInstance = std::make_shared<Singleton>();
            }
        }
        return m_pInstance;
    }
private:
    static std::shared_ptr<Singleton> m_pInstance;
    static std::mutex m_mutex;
};

std::shared_ptr<Singleton> Singleton::m_pInstance = nullptr;
std::mutex Singleton::m_mutex;

上述方式也还是有问题的，使用了智能指针要求用户也使用智能指针，这可以通过从智能指针中获取原始指针并返回原始指针来解决，但是，必须保证用户在外部不要调用delete，且不再用智能指针二次包装原始指针，否则也会引发问题。
另外，在某些平台（与编译器和指令集架构有关），双检锁会失效！
针对上述问题，结合c++11特性，有了以下实现。

class Singleton
{
private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton& GetInstance()
    {
    	//c++11 Magic Static特性:如果当变量在初始化的时候，
    	//并发同时进入声明语句，并发线程将会阻塞等待初始化结束。
    	//Meyers' SingletonMeyer's的单例，
    	//是著名的写出《Effective C++》系列书籍的作者 Meyers 提出的.
        static Singleton instance;
        return instance;
    }
};

上述代码一次解决了多线程问题，内存安全问题，并且利用C++静态变量的生存期是从声明开始到程序结束的特性。该方式是最推荐方式。

2.1.3 饿汉式

饿汉式的实现相对简单，代码如下：

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

Singleton Singleton::m_instance;

上述实现方式在类加载时初始化实例对象，并直到程序结束，不管用户需要还是不需要该单例，称为饿汉式单例，增加了内存占用，是一种以空间换时间的方式。

2.1.4 基于CRTP(奇异的递归模板模式)的单例模式

template<typename T>
class Singleton
{
protected:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    virtual ~Singleton() {}
    static T& GetInstance()
    {
        static T instance;
        return instance;
    }
};

class DerivedSingle :public Singleton<DerivedSingle>
{
    friend class Singleton<DerivedSingle>;
private:
    DerivedSingle() {}
    DerivedSingle(const DerivedSingle&) = delete;
    DerivedSingle& operator = (const DerivedSingle&) = delete;
};

int main(int argc, char* argv[]) 
{
    DerivedSingle& instance1 = DerivedSingle::GetInstance();
    DerivedSingle& instance2 = DerivedSingle::GetInstance();
    return 0;
}

上述代码需要在子类中将基类声明为友元，这样才能调用子类的私有构造函数，使用起来较为不便。在 stackoverflow上， 有大神给出了不需要在子类中声明友元的方法，在这里一并放出;精髓在于使用一个代理类 token，子类构造函数需要传递token类才能构造，但是把 token保护其起来， 然后子类的构造函数就可以是公有的了，这个子类只有 Derived(token)的这样的构造函数，这样用户就无法自己定义一个类的实例了，起到控制其唯一性的作用。改进如下：

template<typename T>
class Singleton
{
protected:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    virtual ~Singleton() {}
    static T& GetInstance()
    {
        static T instance{ token() };
        return instance;
    }
protected:
    struct token {};
};

class DerivedSingle :public Singleton<DerivedSingle>
{
public:
    DerivedSingle(token) {}
    DerivedSingle(const DerivedSingle&) = delete;
    DerivedSingle& operator = (const DerivedSingle&) = delete;
};

int main(int argc, char* argv[]) 
{
    DerivedSingle& instance1 = DerivedSingle::GetInstance();
    DerivedSingle& instance2 = DerivedSingle::GetInstance();
    return 0;
}

3. 致谢

本文主要参考来源C++ 单例模式总结与剖析