面向对象很好地解决了“抽象”的问题,但是为此总是需要付出一些代价,比如说虚函数。对于通常情况来讲,面向对象的成本大都可以忽略不计。但是某些情况,面向对象所带来的成本必须谨慎处理。
动机
在软件系统中,经常有这样一些特殊的雷,必须保证他们在系统中只存在一个实例,才能确保它们的逻辑正确性、以及良好的效率。
比如我们电脑的操作系统的回收站就是一个很好的单例模式应用,电脑上的文件、视频、音乐等被删除后都会进入到回收站中;还有计算机中的打印机也是采用单例模式设计的,一个系统中可以存在多个打印任务,但是只能有一个正在工作的任务;Web页面的计数器也是用单例模式实现的,可以不用把每次刷新都记录到数据库中。
通过回味这些应用场景,我们对单例模式的核心思想也就有了更清晰的认识
简单来说,就是对一个类只可以new一次。
接下来直接上代码
class Singleton {
public:
static Singleton* getInstance();
static Singleton *m_instance;
private:
Singleton();
Singleton(const Singleton& other);
};
Singleton* Singleton::m_instance = nullptr;
下面来看第一种:
//线程非安全版本
Singleton* Singleton::getInstance(){
if(m_instance==nullptr){
m_instance = new Singleton();
}
return m_instance;
}
这种写法很简单,看起来逻辑也正确,但是会出现线程安全问题。
假设最开始的时候,第一次创建对象,Thread A和Thread B同时进入if判断语句,这时m_instance还是nullptr,那么Thread A和Thread B创建了两个对象,类似的,如果有多个Thread,很有可能会出现多个对象。
这种情况违反了单例模式的初衷,因此不可取。
那么这种情况怎么解决呢
加锁
第二种:
/线程安全版本,但锁的代价过高
Singleton* Singleton::getInstance(){
Lock lock;
if(m_instance==nullptr){
m_instance = new Singleton();
}
return m_instance;
}
加锁后,解决了线程安全问题。但是加锁后又出现了一个问题。
假设类已经被实例化,那么在高并发的时候,对于多个线程同时获取对象的时候,只能串行获取,也就是必须等其他线程释放锁后,才可以去竞争获取锁,这会对高性能造成极大影响。
随后,又出现了双检查锁的方式
第三种:
//双检查锁,但由于内存读写reorder不安全
Singleton* Singleton::getInstance(){
if(m_instance==nullptr){
Lock lock;
if(m_instance==nullptr){
m_instance = new Singleton();
}
}
return m_instance;
}
这样看起来是不是对于读线程就没有影响了。
有朋友可能会疑惑,为什么要来两层判断呢?
这是因为在开始对象还没有实例化的时候,多个线程同时进入第一个判断,如果没有第二个判断,那么锁就失效了。
看起来逻辑很正确了,对于并发也没有问题,但是其中又隐藏着另一个问题,那就是内存读写reorder会不安全,会导致双检查锁的失效。
关键在于下面这行代码
m_instance = new Singleton();
一段代码都是有一个指令序列的,通常情况下会认为指令序列会按照想象的流程去执行。但是实际情况中,到了汇编层次,CPU的指令层次后,这个指令有可能和我们的假设不一致。
上面那行程序,如果拆分成三个步骤后,假设中应该是
- 分配内存
- 调用构造器初始化内存
- 将分配的内存的地址赋值给m_instance指针
但是这三个步骤只是我们假想的执行流程,实际上,在CPU指令级别,这三个步骤有可能被reorder,reorder之后有可能变成
- 分配内存
- 将分配的内存的地址赋值给m_instance指针。
- 调用构造器初始化内存
这样就会造成一个问题,假设Thread A港执行完2赋值操作,还没有执行3的时候,Thread B调用getInstance()函数,会获得一个对象。双检查锁欺骗了Thread B, Thread B拿到的m_instance只是分配的原生内存,而没有执行构造器。
这就是双检查锁可能会出现的问题
第四种:
为了解决reorder的问题,java和csharp引入了volatile关键字,告诉编译器,volatile声明的语句的赋值过程不可以被优化,不可以reorder,必须按照假设的流程进行。
c++随后引入了volatile关键字,但是不支持跨平台
c++是一种追求跨平台的语言,C++11版本之后出现了跨平台版本实现。
//C++ 11版本之后的跨平台实现(volatile)
std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;
Singleton* Singleton::getInstance(){
Singleton *tmp = m_instance.load(std::memory_order_relaxed);
//屏蔽编译器的reorder
std::atomic_thread_fence(std::memory_order_acquire); //get memory fence
if(tmp == nullptr){
std::lock_guard<std::mutex> lock(m_mutex);
tmp = m_instance.load(std::memory_order_relaxed);
if(tmp==nullptr){
tmp = new Singleton;
std::atomic_thread_fence(std::memory_order_release); //release memory fence
m_instance.store(tmp,std::memory_order_relaxed);
}
}
return tmp;
}