单例模式原理与C++实现

定义

单例模式，即整个进程中只有一个该类的对象实例，不再有第二个实例，如一个班级只有一个班主任。单例模式有利于节省系统资源。单例类遵循以下设计原则：

• 单例类只能有一个实例
• 单例类必须自己创建自己的唯一实例
• 单例类必须给所有其他对象提供这一实例

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

饿汉模式

class Singleton {
private:
	static Singleton* obj;
	Singleton() {} //私有化构造函数
	Singleton(const Singleton&) {} //私有化拷贝构造函数
public:
	static Singleton* getInstance() {
		return obj;
	}
	void show() {
		cout << "hhh" << endl;
	}
};
//直接在类中创建
Singleton* Singleton::obj = new Singleton;

int main() {
	Singleton* p = Singleton::getInstance();
	p->show();
}

可以看出饿汉模式在使用单例之前就已经创建好了该单例对象。好处是它是线程安全的，且易实现。坏处就是即使不需要该实例，也会进行创建，造成资源浪费，特别是当单例对系统资源消耗较大时。

懒汉模式

class Singleton {
private:
	static Singleton* obj;
	Singleton() {}
	Singleton(const Singleton&) {} 
public:
	static Singleton* getInstance() {
		//在需要时再创建，且只创建一次
		if(obj == nullptr) { 
			obj = new Singleton;
		}
		return obj;
	}
};
Singleton* Singleton::obj = nullptr;

上述懒汉模式就是再用户第一次调用getInstance方法时，才会创建一次单例对象，之后不再创建。优点就是避免资源浪费，缺点就是多线程不安全。当多个线程同时调用getInstance方法时，由于都是第一次调用，并且都判断obj为nullptr，此时将会创建多个实例，因此线程不安全。

懒汉模式之线程安全实现

1.基于static

class Singleton {
private:
	/*...私有化构造和拷贝构造函数略*/
public:
	static Singleton* getInstance() {
		static Singleton* obj = new Singleton;
		return obj;
	}
};

由于static的特性，被其修饰的局部变量只会被初始化一次，并且生存周期延长至整个代码的生存周期，不再受局部作用域的限制。而C++11实现了static的线程安全，所以上述实现是线程安全的。

2.基于锁机制

class Singleton {
private:
	static mutex mtx;
	static Singleton* obj;
	/*...私有化构造和拷贝构造函数略*/
public:
	static Singleton* getInstance() {
		mtx.lock();
		if(obj == nullptr) {
			obj = new Singleton;
		}
		mtx.unlock();
		return obj;
	}
};

上述加锁方式虽然能够解决线程安全问题，但是缺点就是每次获取实例时，都需要执行加解锁过程，这是非常耗时的。

3.基于双重检查锁

#include <mutex>
class Singleton {
private:
	static mutex mtx;
	static Singleton* obj;
	/*...私有化构造和拷贝构造函数略*/
public:
	static Singleton* getInstance() {
		if(obj == nullptr) {
			mtx.lock();
			if(obj == nullptr) {
				obj = new Singleton;
			}
			mtx.unlock();
		}
		return obj;
	}
};

上述方式可以避免每次获取实例时执行加锁和解锁的过程，增加了程序的执行效率。然而这种机制存在一种安全性问题，因为C++在使用new运算符时，首先会分配一块内存，然后将指针指向该内存，此时指针不再为空，但是内存还未完成初始化过程，这需要时间，但是如果在这段时间内，有另外一个线程也调用getInstance方法，那么此线程在第一重判断结果就为假，因此直接返回单例对象，然而此对象还未完成初始化，这会造成安全问题。

双重检查锁安全性检查

#include <thread>
#include <iostream>
#include <mutex>
#include <unistd.h>
#include <condition_variable>
using namespace std;

bool flag = false;

class Singleton {
private:
	char* c;
	static condition_variable_any cond;
	static mutex mtxForFlag;
	static mutex mtx;
	static Singleton* obj;
	Singleton() : c(nullptr){
		cout << "正在构造对象..." << endl;
		mtxForFlag.lock();
		while(!flag) {
			cout << "构造函数被阻塞" << endl;
			cond.wait(mtxForFlag);
		}
		mtxForFlag.unlock();
		c = new char('A');
		cout << "单例创建成功！" << endl;
	}
	Singleton(const Singleton&) {}
public:
	static Singleton* getInstance() {
		if (obj == nullptr) {
			cout << "进来一个线程" << endl;
			mtx.lock();
			if (obj == nullptr) {
				cout << "开始构造" << endl;
				obj = new Singleton;
				cout << "构造结束" << endl;
			}
			mtx.unlock();
		}
		return obj;
	}
	void show() {
		cout << c;
		mtxForFlag.lock();
		flag = true;
		mtxForFlag.unlock();
		cond.notify_one();
	}
};
Singleton* Singleton::obj = nullptr;
mutex Singleton::mtx;
mutex Singleton::mtxForFlag;
condition_variable_any Singleton::cond;

void testInstance(int sec) {
	sleep(sec);
	Singleton* p = Singleton::getInstance();
	p->show();
}

int main(void) {
	thread t1(testInstance, 0);
	thread t2(testInstance, 5);
	t1.join();
	t2.join();
	return 0;
}

执行结果如下所示：

进来一个线程
开始构造
正在构造对象...
构造函数被阻塞
进来一个线程

上述结果表明，线程1第一次调用getInstance方法，进入构造函数，开始构造对象，这个时候让其阻塞在构造函数中，因此构造过程未完成，直观的就是成员变量c指针没有指向新的内存地址。然后在5秒之后，线程2调用getInstace方法，此时在第一步判断obj时，obj应该为非空，因为内存已经分配好，只是构造函数还未完成初始化，然而事实上，此时的obj仍然为空，因为最后一次输出“进来一个线程”表示，线程2通过了第一重检查。最终线程2在等待锁而阻塞，而线程1也在等待条件变量而阻塞。
总之，此次实验表明在初始化完成之前，即使分配了内存，单例对象指针仍然为空。这是否表明双重检查锁就是安全的呢，不会有所谓的对象返回，而对象未初始化的问题呢？疑惑？？