C++设计模式——单例类
C++设计模式——单例类
本文假设有一个Manager管理类，探讨单例类懒汉/饿汉模式的实现，和单例类的多线程安全性，最后介绍Meyers Singleton写法。
懒汉模式
当第一次要用单例类的时候，再产生实例。是一种典型的拖延（lazy）策略。
类声明：
class Manager
{
public:
~Manager();
static Manager* getInstance();//提供单例对象访问
static void deleteInstance();//删除单例对象
void dosomething();
protected:
Manager();//构造函数声明为 protected
static Manager* s_Manager;//单例对象指针
};
类定义：
//单例对象指针初始化为nullptr，防止指向了未定义的数据
Manager* Manager::s_Manager = nullptr;
//提供单例类对象访问
Manager* Manager::getInstance(){
//当没有存在实例时（一般是指准备第一次用）时，才生成新实例
if(!s_Manager)
s_Manager = new CacheManger();
return s_Manager;
}
//删除单例类
void Manager::deleteInstance(){
if(s_Manager){
deleted s_Manager;
s_Manager = nullptr;//别忘了赋予空指针，否则指向未定义数据
}
}
void Manager::dosomething(){
//dosometing
}
使用此类时就可以通过：
Manager::getInstance()->dosomething();
来运用单例类来做某些操作了。
懒汉模式with线程安全
上面的例子，并不能保证线程安全。
假如没有实例时，某两个线程都几乎同时使用getInstance()，那么很可能会产生2份实例，其中一份还会变成泄露的内存。
为了解决线程安全问题，本文使用了C++11<mutex>的std::mutex作为互斥锁，在类额外增加了一个静态变量std::mutext s_mtx;。
//提供单例类对象访问
Manager* Manager::getInstance() {
if (!s_Manager) //检查
{//上锁
std::lock_guard<std::mutex> lock(s_mtx);
if (!s_Manager)
s_Manager = new Manager();
}//解锁
return s_Manager;
}
//删除单例类
void Manager::deleteInstance() {
if (s_Manager) //检查
{//上锁
std::lock_guard<std::mutex> lock(s_mtx);
if (s_Manager)
{
delete s_Manager;
s_Manager = nullptr;
}
}//解锁
}
为什么不是（上锁，检查，操作，解锁）或者（检查，上锁，操作，解锁），而是使用了双重检查（检查，上锁，检查，操作，解锁）？
- 上锁的成本远远比检查空指针要高，且当需要产生实例时才需要锁操作。而实际上大量多次使用getInstance时（因为已经产生了实例）并不需要上锁，若先上锁，则会严重造成性能阻塞。
- 仅仅是检查后再上锁，则根本没有做到任何线程安全。
饿汉模式
饿汉模式与懒汉模式相反，一开始就生成唯一实例。这样就不用检查是否存在实例，而且也无需考虑产生实例时的线程安全。
class Manager {
public:
~Manager();
//提供单例对象访问
static Manager* getInstance();
void dosomething();
protected:
//构造函数声明为 保护方法
Manager();
//单例对象指针
static Manager* s_Manager;
};
//提供单例类对象访问
Manager* Manager::getInstance(){
return s_Manager;
}
使用方法：
Manager::getInstance()->dosomething();
可以看到代码比懒汉模式简单多了。在大量使用检查空指针造成的性能瓶颈而内存始终充足时，可以考虑使用饿汉模式
Meyers Singleton
目前最推荐的C++单例写法
class Manager {
public:
static Manager& Instance() {
static Manager theManager;
return theManager;
}
private:
Manager();
Manager(Manager const&);
Manager& operator = (Manager const&);
~Manager();
};
这段代码很简单，虽然看上去和懒汉模式类似，只是static变量的位置从类移动到了实例获取函数内。但是实际上由于C++的机制，当第一次调用该函数时，实例才会被构建出来。这样既可以得到饿汉模式的线程安全，又可以有懒汉模式的按需分配的功能。
应用场景
单例类设计模式算是比较经典的一个模式，但是需要注意，它并不是想象中那么美好。
- 它是一种换皮的全局变量。
- 它促进了耦合。
- 它可能对并发不友好（取决于你使用的单例写法）。
一些替代方案：
- 当你仅需要全局可见的方法时，应该用类静态方法而不是一个类实例。
- 尽可能为实例提供其它便捷的访问方式（传参/基类获取/服务定位器获取等），而不是通过提供全局可见的访问方式。
- 如果你只是需要类保证只有唯一对象而不需要全局性，那么应对外封闭获取实例接口（其实就是不可全局获取实例的）。
所以要注意单例类设计模式不应被泛用，通过上面的替代方案多多少少也就减少了很多不必要的单例设计。
