转自:http://blog.csdn.net/qq_35280514
单例模式
在一些情形下,保持类的实例只有一个非常重要。例如:一个表示文件系统的Class。一个操作系统一定是只有一个文件系统的,因此,我们希望表示文件系统的类实例有且仅有一个。单例模式 是设计模式中一种实现这一类需求的设计方法。
单例模式(Singleton),保证一个类仅有一个实例,并提供一个访问它的全局访问点。 [1]
全局静态变量能够实现对象的全局访问,但这不能防止你实例化多个类实例。为了实现上述要求,我们需要加强类的设计,让类自身保证其实例仅有一个。也就是说,“这个类可以保证没有其它实例可以被创建,并且它可以提供一个访问该实例的方法。”[1]
一般来说,单例类的结构如下:
class Singleton {
public:
static Singleton* GetInstance(); //供用户获取单例的全局访问点
protected:
Singleton(); //方便继承,同时保证类的用户无法直接构造该类的实例
Singleton(const Singleton&);
private:
//class members
};
- 问题:1. 要不要将赋值构造函数、取地址符保护起来
- 2. 返回指针还是引用
C++中static对象的初始化
C++规定,non-local static 对象的初始化发生在main函数执行之前。但C++没有规定多个non-local static 对象的初始化顺序,尤其是来自多个编译单元的non-local static对象,他们的初始化顺序是随机的。
然而,对于local static 对象,其初始化发生在控制流第一次执行到该对象的初始化语句时。 non-local static对象的初始化发生在main函数之前的单线程启动阶段,所以无需担心线程安全问题。但是local static对象则不同,多个线程的控制流可能同时到达其初始化语句。
在C++11之前,在多线程环境下local static对象的初始化并不是线程安全的。[2]具体表现就是:如果一个线程正在执行local static对象的初始化语句但还没有完成初始化,此时若其它线程也执行到该语句,那么这个线程会认为自己是第一次执行该语句并进入该local static对象的构造函数中。这会造成这个local static对象的重复构造,进而产生内存泄露问题。
在文章的后半部分会看到,local static 对象在单例模式中有着广泛的应用,为了解决local static对象在多线程环境下的重复构造问题,程序员想出了很多方法。而C++11则在语言的规范中解决了这个问题。C++11规定,在一个线程开始local static 对象的初始化后完成初始化前,其他线程执行到这个local static对象的初始化语句就会等待,直到该local static 对象初始化完成。 [2]
C++实现单例模式
单例模式的实现分为两大类,懒汉模式和饿汉模式。懒汉模式的单例秉承着实例能晚一点构造就晚一点构造的思想,直到第一次使用单例时才构造单例;饿汉模式则恰好相反,即使实例永远不会被使用,实例的构造还是会早早的发生。
懒汉模式
饿汉模式有以下几点要求:保证类实例是唯一的;提供全局可访问点;延迟构造,直到第一次使用该实例。
以下是几种懒汉模式的单例模式实现.[3][8] 他们或者利用了local static 对象的特性,或者使用指针来判断对象是否是第一次初始化。在多线程条件下,则需要互斥锁以避免重复构造问题
首先是《设计模式》[1]中给出的单例模式实现。
template<class T>
T& Singleton() {
static T instance;
return instance;
}
这一实现在C++98中不是线程安全的,具体原因参考上一节关于static对象的初始化的讨论。
为了解决上一段代码中存在线程安全问题,最简单的方法是使用互斥锁在开始初始化之前先获取锁。
std::mutex m; //必须是一个全局变量而不是一个局部变量
template<class T>
T& Singleton() {
std::unique_lock lock(m); //析构函数自动 unlock
static T instance;
return instance;
}
但是,线程安全问题只是出现在第一次初始化过程。然而,以上代码却为了一次初始化而使得每一次获取Singleton都要首先获取锁资源,Singleton的访问变成了串行。这显然不太合算。
为了避免每一次都加锁我们可以事先判断是否已经初始化。Double Check Lock 是一种常用的实现手法。如下:
class Singleton;
class Singleton {
private:
Singleton();
Singleton(const Singleton &);
public:
static Singleton& GetInstance() {
if(m_instance == nullptr) {
std::unique_lock lock(m); //析构函数自动 unlock
if(m_instance == nullptr) {
m_instance = new Singleton;
}
}
return *m_instance;
}
private:
static Singleton *m_instance = nullptr;
static std::mutex m;
//other class members
}
如果内存访问严格按照语句先后顺序进行,那么以上代码堪称完美解决了所有问题。但是,在某些内存模型中(虽然不常见)或者是由于编译器的优化以及运行时优化等等原因,使得m_instance虽然已经不是nullptr但是其所指对象还没有完成构造,这种情况下,另一个线程如果调用GetInstance()就有可能使用到一个不完全初始化的对象。(double check 中的互斥锁在此处是不起作用的)
内存屏障 [7]可以强制要求内存完成屏障前的所有内存读写操作。C++11提供了Atomic实现内存的同步访问,即不同线程总是获取对象修改前或修改后的值,无法在对象修改期间获得该对象。参考资料3中给出了多个实现内存同步访问的示例。以下是利用atomic实现的版本:
class Singleton;
class Singleton {
private:
Singleton();
Singleton(const Singleton &);
public:
static Singleton& GetInstance() {
if(m_instance == nullptr) {
std::unique_lock lock(m); //析构函数自动 unlock
if(m_instance == nullptr) {
m_instance = new Singleton;
}
}
return *m_instance;
}
private:
static std::atomic<Singleton *> m_instance(nullptr);
static std::mutex m;
//other class members
}
综合以上种种我们发现,迫使我们做各种繁琐工作的罪恶来源是C++98中没有规定local static 对象在多线程条件下的初始化行为。然而在上一节的讨论中我们知道C++11给出了规定。[2]。因此,在C++11标准下一个线程安全的单例模式可以这样实现。这种方法也被称为Meyers’ Singleton:
class Singleton;
class Singleton {
private:
Singleton();
Singleton(const Singleton &);
public:
static Singleton& GetInstance() {
static Singleton instance; //C++11标准下local static对象初始化在多线程条件下安全
return instance;
}
private:
//class members
}
是不是有一种大道至简的感觉?这和我们最开始给出的形式一模一样。但是注意,此时的语言标准变了,在C++11标准下这样写才是线程安全的。另外GCC4.3和VS2015之后的版本也开始支持该特性。[2]。
饿汉模式
饿汉模式下同样要求单例是类的唯一实例,且需要类提供一个全局访问点。但是与懒汉模式不同,饿汉模式中单例的构造会尽可能早的进行,即使目前不会用到,甚至以后永远也不会用到。
以下是几种饿汉模式的单例模式实现.[4] 从上一节的讨论中我们可以知道 non-local static对象符合饿汉模式对于单例构造应该尽早进行的要求。然而,一旦使用了non-local static对象我们就不得不小心多个non-local static 对象的初始化问题。[6]
class Singleton {
private:
Singleton();
Singleton(const Singleton &);
struct InstanceCreator {
InstanceCreator() {
Singleton::m_instance = new Singleton;
}
~InstanceCreator() {
delete Singleton::m_instance;
Singleton::m_instance = nullptr;
}
};
public:
static Singleton& GetInstance() {
return *m_instance;
}
private:
friend class InstanceCreator;
static Singleton *m_instance;
static InstanceCreator m_creator;
};
如果没有其他non-local static 对象使用这个单例,那么上述代码是可以正常使用的。
然而,在有其他non-local static 对象使用该单例时,上述代码就会出现问题。由于non-local static对象初始顺序的不确定性,我们无法让具有依赖关系的两个non-local static对象按照依赖关系的固定顺序初始化。
事实上,在绝大多数条件下,类的设计阶段我们无法得知会不会有一个non-local static 对象依赖于这个单例,即使可以确定目前没有其他non-local static对象依赖于这个单例,那也无法确定在以后也不会有。所以我们需要设计一个方案来应对可能出现的两种情况。以下代码可以满足这种需求
class Singleton {
private:
Singleton();
Singleton(const Singleton &);
struct InstanceCreator { //真正负责单例的构造和析构
InstanceCreator() {
Singleton::m_instance = new Singleton;
}
~InstanceCreator() {
delete Singleton::m_instance;
Singleton::m_instance = nullptr;
}
};
struct InstanceConfirm { //没有non-loacl static对象依赖时,保证在main函数前初始化
InstanceConfirm() {
Singleton::GetInstance();
}
}
public:
static Singleton& GetInstance() { //全局访问点
static InstanceCreator creator; //有non-local static对象依赖时确保初始化顺序。
return *m_instance;
}
private:
friend class InstanceCreator;
friend class InstanceConfirm;
static Singleton *m_instance;
static InstanceConfirm m_confirm; //最后保证main函数之前完成初始化
};
以上代码在C++98标准下也可以正常工作,唯一的要求是在main函数之前进程是单线程的。
C++单例模式的实现总结
在C++单例模式的多种实现中,Meyers’ Singleton是绝对的第一选择!但要注意的是,其多线程安全性在C++11的标准下才能得以保证(或者编译器特性支持)[2]。。
如果由于各种原因(包括为兼容旧代码等等)Meyers’ Singleton无法在多线程条件下工作。那么,个人认为也没有必要为了强行实现懒汉模式而搞一大堆的同步代码[3][7][8] ,直接实现一个饿汉模式的单例即可[4]。这一过程应该注意多个non-local static 对象的初始化次序问题[6]。
【参考资料】
[1] Erich G, H Richard等著,李英军, 马晓星等译. 设计模式:可复用面向对象软件的基础. 北京:机械工业出版社, 2000.9, 84-89
[2] Stack Overflow: Is Meyers implementation of Singleton pattern thread safe?. Groo的回答.
[3] .KlayGE游戏引擎:C++中线程安全并且高效的Singleton
[4] 知乎: 求教一个百度的面试题,关于多线程单例模式的?. 知乎用户的回答
[5] 程杰 著. 大话设计模式. 北京:清华大学出版社, 2007.12, 214-219
[6] Scott Meyers 著, 侯捷 译. Effective C++(第三版)中文版,北京:电子工业出版社, 2011.1, 26-32
[7] 百度百科:内存屏障
[8] 老司机. 博客园:C++程序员们,快来写最简洁的单例模式吧