前言
最近个人在写一些小的练手的项目，发现单例模式的应用实在是很广泛，很多情况下一个类都需要使用单例模式来实现，因此这里我再度总结一下单例模式的实现，之前已经总结过一次，当时的例子给的是muduo的单例模式实现，这次再给出几种其他的实现，同时进行一下比较。
饿汉模式
饿汉模式就是在还未使用变量的时候，已经对该变量进行赋值，有点类似很饥饿的感觉，在main函数开始执行前就已经初始化好了，因此是线程安全的。
不考虑析构函数的饿汉模式实现
#include <iostream>
using namespace std;
class singleton
{
protected:
singleton() {};
private:
singleton(const singleton&) {};
singleton& operator=(const singleton&) {};
static singleton* m_instance;
public:
static singleton* GetInstance();
~singleton()
{
printf("Singleton destruction\n");
}
};
singleton* singleton::GetInstance()
{
return m_instance;
}
singleton* singleton::m_instance = new singleton;
int main()
{
singleton *ct = singleton::GetInstance();
return 0;
}
饿汉模式的优点
- 线程安全
- 简单易懂易实现
饿汉模式的缺点
- 不适合对性能有要求的场景，因为有些场景下可能不会用到这个变量，这样就无需加载
- 在main函数之前就已经初始化完成，基本上没办法给类传入参数
懒汉模式
这个从名字上更容易理解，懒汉就是不到万不得已绝不行动，对于单例模式来说就是默认情况下变量不初始化为nullptr，而在GetInstance方法被调用的时候才会判断instance是否已经被初始化，然后再决定是否要初始化，不过这个行为导致的一个重要问题就是线程不安全。
不考虑析构函数的懒汉模式实现
#include <iostream>
using namespace std;
class singleton
{
protected:
singleton() {};
private:
singleton(const singleton&) {};
singleton& operator=(const singleton&) {};
static singleton* m_instance;
public:
static singleton* GetInstance();
~singleton()
{
printf("Singleton destruction\n");
}
};
singleton* singleton::GetInstance()
{
if (m_instance == NULL)
{
m_instance = new singleton;
}
return m_instance;
}
singleton* singleton::m_instance = NULL;
int main()
{
singleton *ct = singleton::GetInstance();
return 0;
}
解决懒汉模式线程不安全的几种方法
使用局部静态变量
局部静态变量的初始化是线程安全的，这一点由编译器保证.（http://gcc.gnu.org/ml/gcc-patches/2004-09/msg00265.html). 这是一个 GCC 的 patch，专门解决这个问题）。会在程序退出的时候自动销毁。不过需要注意的是，这个方法适合 C++11，C++11保证静态局部变量的初始化是线程安全的。如果是 C++98 就不能用这个方法。
class S
{
public:
static S& getInstance()
{
static S instance;
return instance;
}
private:
S() {}
S(S const&) = delete; // Don't Implement.
void operator=(S const&) = delete; // Don't implement
};
加锁
这个办法应该是最简单最直接的了，代码实现如下：
// singleton.h
class Singleton {
public:
static Singleton *GetInstance() {
std::lock_guard<std::mutex> lck(mutex_);
if (p == NULL) {
p = new Singleton;
}
return p;
}
private:
std::mutex mutex_;
static Singleon *p;
Singleton() {}
Singleton(const Singleton &) = delete;
Singleton& operator= (const Singleton &) = delete;
};
// singleton.cpp
Singleton *Singleton::p = NULL;
这个方法的缺点是每次调用GetInstance都会加锁，在多线程的情况下可能会轻微增加程序的负担。
pthread_once
这个是我在以前推荐的博客里面写的，陈硕推荐的单例模式实现，是一个非常好的实现方式，不过仅限于在linux系统下
// singleton.h
class Singleton {
public:
static Singleton *GetInstance() {
pthread_once(&ponce_, &Singleton::init);
return value_;
}
private:
Singleton() {}
Singleton(const Singleton &) = delete;
Singleton& operator= (const Singleton &) = delete;
static void init() {
value_ = new T();
}
static pthread_once_t ponce_;
static Singleton *value_;
};
// singleton.cpp
pthread_once_t SIngleton::ponce_ = PTHREAD_ONCE_INIT;
Singleton* Singleton::value_ = NULL;
Double Check Locking(DCL)
double check locking. 只能用内存屏障，其他做法都是有问题的。普通的 double check 之所以错，是因为乱序执行和多处理器下，不同 CPU 中间 cache 刷往内存并对其他 CPU 可见的顺序无法保障（cache coherency problem）。比如
Singleton<T> *p = new Singleton<T>;
这个语句的实际执行过程有三步：
- 分配内存
- 构造对象
- 赋值给p
由于乱序执行，因此2和3的执行顺序实际上是不一定的。因此，如果在某些情况下，3先于2执行，那么就会出现p实际上指向一个无效的对象，但是由于p已经不再是空指针，所以在DCL的第一步判断p是否为空指针时，顺利通过，然后p被返回，然而此时的p指向的内存是位被构造的。
可能有同学认为可以增加一个临时变量temp_p，当temp_p构造完成之后再赋值给p，但是对于现代的编译器这样做是没有意义的，因为现代编译器会认为temp_p是无效的，可能会被优化掉，因此就回到了上一个问题，因此DCL不是线程安全的。
自动调用析构函数
在前面说的懒汉模式不考虑析构函数和饿汉模式不考虑析构函数中，代码中我们虽然都写了析构函数，但是如果我们运行的话会发现，其实析构函数并不会被调用，这是为什么呢，其实答案很简单，因此我们的对象是new出来的，然而我们并没有显式的调用delete，因此析构函数自然不会被调用，那么我们是需要手动调用析构函数吗，其实并非如此，我们希望一种可以自动调用析构函数的方式来实现，其实也很简单，就是之前说的局部静态变量，实现如下，其实和之前一样：
#include <iostream>
using namespace std;
class singleton
{
protected:
singleton() {};
private:
singleton(const singleton&) {};
singleton& operator=(const singleton&) {};
public:
static singleton* GetInstance();
~singleton()
{
printf("Singleton destruction\n");
}
};
singleton* singleton::GetInstance()
{
static singleton m_instance;
return &m_instance;
}
int main()
{
singleton *ct = singleton::GetInstance();
return 0;
}
其实写到这里基本就差不多了，不过这个方法的缺点就是只有在c++11标准下才能保证其正确性，不过从目前来看，c++11的普及性已经很好了，所以基本上不怎么需要担心这个问题
总结
其实说到这里，单例模式就讲的差不多了，陈硕推荐的pthread_once方法和c++11下静态局部变量的方法都是很不错的，值得学习。
本文首发于我的公众号：码农手札，主要介绍linux下c++开发的知识包括网络编程的知识同时也会介绍一些有趣的算法题，欢迎大家关注，利用碎片时间学习一些编程知识，冰冻三尺非一日之寒，让我们一起加油！
