【设计模式】 单例模式

单例可能是最常用的简单的一种设计模式，某个对象全局只需要一个实例时，就可以使用单例模式。实现方法多样，根据不同的需求有不同的写法；同时单例也有其局限性，因此有很多人是反对使用单例的。

本文对C++ 单例的常见写法进行了一个总结, 包括懒汉式、线程安全、单例模板等； 按照从简单到复杂，最终回归简单的的方式循序渐进地介绍，并且对各种实现方法的局限进行了简单的阐述，大量用到了C++ 11的特性如智能指针, magic static，线程锁；从头到尾理解下来，对于学习和巩固C++语言特性还是很有帮助的。

一、什么是单例

单例（Singleton）是设计模式的一种，其特点是只提供唯一一个类的实例，具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例。它的优点显而易见：

• 它能够避免对象重复创建，节约空间并提升效率。
• 避免由于操作不同实例导致的逻辑错误。

单例模式有两种实现方式：饿汉式和懒汉式。

• 饿汉：饿了肯定要饥不择食。所以在单例类定义的时候就进行实例化。（本身就是线程安全的）
• 懒汉：故名思义，不到万不得已就不会去实例化类，也就是说在第一次用到类实例的时候才会去实例化。与之对应的是饿汉式单例。（注意，懒汉本身是线程不安全的）

关于如何选择懒汉和饿汉模式：

• 懒汉：在访问量较小时，采用懒汉实现。这是以时间换空间。
• 饿汉：由于要进行线程同步，所以在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。

二、C++单例的实现

基础要点如下：

• 全局只有一个实例：static 特性，同时禁止用户自己声明并定义实例（把构造函数设为 private）
• 线程安全
• 禁止赋值和拷贝
• 用户通过接口获取实例：使用 static 类成员函数

下面介绍 C++ 实现单例的几种方式。

2.1 饿汉式

饿汉式：变量在声明时便初始化。

#include <iostream>

using namespace std;

class Singleton {
public:
    // 析构函数
    ~Singleton(){
        cout << "destructor called!" << endl;
    }

    // 获取唯一的实例
    static Singleton* getInstance() {
        return m_instance;
    }

    void use() const {
        cout << "in use" << endl;
    }

private:
    // 构造函数定义为 private，这就保证了必须通过getInstance方法才能获取到唯一的m_instance实例
    Singleton() {
        cout << "constructor called!" << endl;
    }

    // 定义唯一的实例
    static Singleton *m_instance;
};

// 饿汉式的关键：初始化即实例化
Singleton *Singleton::m_instance = new Singleton();

int main(){
    Singleton* instance = Singleton::getInstance();
    Singleton* instance2 = Singleton::getInstance();
    return 0;
}

运行的结果是

constructor called!

可以看到，我们将构造方法定义为 private，这就保证了其他类无法实例化此类，必须通过 getInstance 方法才能获取到唯的 instance 实例，非常直观。但饿汉式有一个弊端，那就是即使这个单例不需要使用，它也会在类加载之后立即创建出来，占用一块内存，并增加类初始化时间就好比一个电工在修理灯泡时，先把所有工具拿出来，不管是不是所有的工具都用得上。就像一个饥不择食的饿汉，所以称之为饿汉式。

2.2 有缺陷的懒汉式

懒汉式(Lazy-Initialization)的方法是直到使用时才实例化对象，也就说直到调用 get_instance() 方法的时候才 new 一个单例的对象。好处是如果被调用就不会占用内存。

#include <iostream>

using namespace std;

class Singleton {
public:
    // 析构函数
    ~Singleton(){
        cout << "destructor called!" << endl;
    }

    // 获取唯一的实例
    static Singleton* getInstance() {
        if(m_instance==nullptr) {
              m_instance = new Singleton;
        }
        return m_instance;
    }

    void use() const {
        cout << "in use" << endl;
    }
    
private:
    // 构造函数定义为 private，这就保证了必须通过getInstance方法才能获取到唯一的m_instance实例
    Singleton() {
        cout << "constructor called!" << endl;
    }

    // 定义唯一的实例
    static Singleton* m_instance;
};

Singleton* Singleton::m_instance = nullptr;

int main(){
    Singleton* instance = Singleton::getInstance();
    Singleton* instance2 = Singleton::getInstance();
    return 0;
}

运行的结果是

constructor called!

可以看到，获取了两次类的实例，却只有一次类的构造函数被调用，表明只生成了唯一实例，这是个最基础版本的单例实现，他有哪些问题呢？

• 线程安全的问题：当多线程获取单例时有可能引发竞态条件：第一个线程在 if 中判断 m_instance是空的，于是开始实例化单例；同时第 2 个线程也尝试获取单例，这个时候判断m_instance还是空的，于是也开始实例化单例；这样就会实例化出两个对象，这就是线程安全问题的由来；解决办法：加锁。
• 内存泄漏：注意到类中只负责 new 出对象，却没有负责 delete 对象，因此只有构造函数被调用，析构函数却没有被调用；因此会导致内存泄漏。解决办法：使用共享指针。

因此，这里提供一个改进的，线程安全的、使用智能指针的实现。

2.3 线程安全、内存安全的懒汉式单例 （智能指针，锁）

#include <iostream>
#include <memory> // shared_ptr
#include <mutex>  // mutex

using namespace std;

class Singleton{
public:
    typedef shared_ptr<Singleton> sharedPtr;

    // 析构函数
    ~Singleton(){
        cout << "destructor called!" << endl;
    }

    // 获取唯一的实例
    static sharedPtr getInstance() {
        // 双检锁
        if(m_instance==nullptr) {
            lock_guard<mutex> lk(m_mutex);
            if(m_instance == nullptr) {
              m_instance = shared_ptr<Singleton>(new Singleton);
            }
        }
        return m_instance;
    }


private:
    Singleton() {
        cout << "constructor called!" << endl;
    }

    static sharedPtr m_instance; // 定义唯一的实例
    static mutex m_mutex;
};

// 在类外初始化静态变量
Singleton::sharedPtr Singleton::m_instance = nullptr;
mutex Singleton::m_mutex;

int main(){
    Singleton::sharedPtr instance = Singleton::getInstance();
    Singleton::sharedPtr instance2 = Singleton::getInstance();
    return 0;
}

运行结果如下，发现确实只构造了一次实例，并且发生了析构。

constructor called!
destructor called!

shared_ptr 和 mutex 都是C++11的标准，以上这种方法的优点是

• 基于 shared_ptr，用了 C++ 比较倡导的 RAII 思想，用对象管理资源，当 shared_ptr 析构的时候，new 出来的对象也会被 delete 掉。以此避免内存泄漏。
• 加了锁，使用互斥量来达到线程安全。这里使用了两个 if 判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，避免每次调用 getInstance 的方法都加锁，锁的开销毕竟还是有点大的。

不足之处在于： 使用智能指针会要求用户也得使用智能指针，非必要不应该提出这种约束；使用锁也有开销；同时代码量也增多了，实现上我们希望越简单越好。

还有更加严重的问题，在某些平台（与编译器和指令集架构有关），双检锁会失效！

因此这里还有第三种的基于Magic Staic的方法达到线程安全。

2.4 最推荐的懒汉式单例(magic static )——局部静态变量

#include <iostream>

using namespace std;

class Singleton
{
public:
    // 析构函数
    ~Singleton() {
        cout << "destructor called!" << endl;
    }

    // 获取唯一的实例
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }

private:
    // 构造函数定义为 private，这就保证了必须通过getInstance方法才能获取到唯一的m_instance实例
    Singleton() {
        cout << "constructor called!" << endl;
    }
};

int main(int argc, char *argv[])
{
    Singleton& instance_1 = Singleton::getInstance();
    Singleton& instance_2 = Singleton::getInstance();
    return 0;
}

运行结果

constructor called!
destructor called!

这种方法又叫做 Meyers' Singleton， 是著名的写出《Effective C++》系列书籍的作者 Meyers 提出的。所用到的特性是在C++11标准中的Magic Static特性：

If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.
如果当变量在初始化的时候，并发同时进入声明语句，并发线程将会阻塞等待初始化结束。

这样保证了并发线程在获取静态局部变量的时候一定是初始化过的，所以具有线程安全性。

C++ 静态变量的生存期是从声明到程序结束，这也是一种懒汉式。

这是最推荐的一种单例实现方式：

• 通过局部静态变量的特性保证了线程安全（C++11, GCC > 4.3, VS2015 支持该特性）；
• 不需要使用共享指针，代码简洁；
• 注意在使用的时候需要声明单例的引用Single&才能获取对象。

另外网上有人的实现返回指针而不是返回引用：

static Singleton* get_instance(){
    static Singleton instance;
    return &instance;
}

这样做并不好，理由主要是无法避免用户使用delete instance导致对象被提前销毁。还是建议大家使用返回引用的方式。

2.5 函数返回引用

有人在网上提供了这样一种单例的实现方式：

#include <iostream>

using namespace std;

class A
{
public:
    A() {
        cout << "constructor" << endl;
    }
    ~A(){
        cout << "destructor" << endl;
    }
};


A& retSingleton(){
    static A instance;
    return instance;
}

int main(int argc, char *argv[])
{
    A& instance_1 = retSingleton();
    A& instance_2 = retSingleton();
    return 0;
}

输出如下：

constructor called!
destructor called!

严格来说，这不属于单例了，因为类 A 只是个寻常的类，可以被定义出多个实例，但是亮点在于提供了retSingleton的方法，可以返回一个全局（静态）变量，起到类似单例的效果，这要求用户必须保证想要获取全局变量 A ，只通过retSingleton() 的方法。

以上是各种方法实现单例的代码和说明，解释了各种技术实现的初衷和原因。这里会比较推荐 C++11 标准下的 2.4 的方式，即使用静态局部变量的方法，简单的理由来说是因为其足够简单却满足所有需求和顾虑。

在某些情况下，我们系统中可能有多个单例，如果都按照这种方式的话，实际上是一种重复，有没有什么方法可以只实现一次单例而能够复用其代码从而实现多个单例呢？ 很自然的我们会考虑使用模板技术或者继承的方法。

三、单例的模板

3.1 CRTP 奇异递归模板模式实现

代码示例如下：

#include <iostream>

using namespace std;

template<typename T>

// 基类
class Singleton {
public:
    // 析构函数
    virtual ~Singleton() {
        cout << "destructor called!" << endl;
    }

    static T& getInstance() {
        static T instance;
        return instance;
    }

protected:
    // 构造函数
    Singleton() {
        cout << "constructor called!" << std::endl;
    }
};

// 派生类（子类需要将自己作为模板参数T，传递给Singleton<T>模板）
class DerivedSingle : public Singleton<DerivedSingle> {
private:
    // 同时将基类声明为友元，这样才能调用子类的私有构造函数，这样才能调用子类的私有构造函数
    friend class Singleton<DerivedSingle>;

    DerivedSingle() = default;
};

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

以上实现一个单例的模板基类，使用方法如例子所示意，子类需要将自己作为模板参数T 传递给Singleton<T>模板; 同时需要将基类声明为友元，这样才能调用子类的私有构造函数。

基类模板的实现要点是：

（1）构造函数需要是protected，这样子类才能继承；

（2）使用了奇异递归模板模式CRTP(Curiously recurring template pattern)；

（3）getInstance 方法和 2.4 的静态局部变量方法一个原理；

（4）在这里基类的析构函数可以不需要 virtual，因为子类在应用中只会用 Derived 类型，保证了析构时和构造时的类型一致。

3.2 不需要在子类声明友元的实现方法

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

#include <iostream>

using namespace std;

template<typename T>

// 基类
class Singleton {
public:
    static T& getInstance() noexcept(std::is_nothrow_constructible<T>::value) {
        static T instance{ token() };
        return instance;
    }

    virtual ~Singleton() = default;

protected:
    struct token{}; // 代理类token
    Singleton() noexcept = default;
};

// 派生类
class DerivedSingle : public Singleton<DerivedSingle> {
public:
    // 子类构造函数需要传递token类才能构造，但是把token保护起来，然后子类的构造函数就可以是公有的了
    DerivedSingle(token) {
        cout << "destructor called!" << endl;
    }

    ~DerivedSingle(){
        cout << "constructor called!" << endl;
    }
};

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

3.3 函数模板返回引用

在 2.5 中提供了一种类型的全局变量的方法，可以把一个一般的类，通过这种方式提供一个类似单例的全局性效果（但是不能阻止用户自己声明定义这样的类的对象）；在这里我们把这个方法变成一个 template 模板函数，然后就可以得到任何一个类的全局变量。

#include <iostream>

using namespace std;

class A
{
public:
    A() {
        cout << "constructor" << endl;
    }
    ~A(){
        cout << "destructor" << endl;
    }
};

template<typename T>
T& get_global() {
    static T instance;
    return instance;
}

int main(int argc, char *argv[])
{
    A& instance_1 = get_global<A>();
    A& instance_2 = get_global<A>();
    return 0;
}

输出如下：

constructor called!
destructor called!

可以看到这种方式确实非常简洁，同时类仍然具有一般类的特点而不受限制，当然也因此失去了单例那么强的约束（禁止赋值、构造和拷贝构造）。
这里把函数命名为get_global()是为了强调，这里可以通过这种方式获取得到单例最重要的全局变量特性，但是并不是单例的模式。