C++：单例模式——线程安全模式、饥汉模式、懒汉模式

简介

单例模式：意思是一个类只能实例化一个对象，且无法通过拷贝构造，赋值构造等方法构造对象。

在理解单例模式之前，要先了解 static关键字的用法可在此查看：

链接: static关键字详解.

线程安全模式

class Object
{
private:
	int value;
	static Object instance;
private:
	Object(int x = 0) : value(x) {}
	Object(const Object& obj) = delete;
	Object& operator =(const Object& obj) = delete;

public:
	static Object& GetInstance()
	{
		return instance;
	}
};

Object Object::instance(10);

可以看出无法通过构造函数实例化对象，只有一个静态的对象。

调用示例：

#include<thread>

void funa()
{
	Object& obja = Object::GetInstance();
	cout << "obja " << &obja << endl;
}
void funb()
{
	Object& objb = Object::GetInstance();
	cout << "objb " << &objb << endl;
}
int main(void)
{
	thread thra(funa);
	thread thrb(funb);

	thra.join();
	thrb.join();

	return 0;
}

在引入多线程时，所使用的仍然是同一个对象。

饥汉模式

class Object
{
private:
	int value;
private:
	Object(int x = 0) : value(x) {}
	Object(const Object& obj) = delete;
	Object& operator =(const Object& obj) = delete;

public:
	static Object& GetInstance(int x)
	{
		static Object instance(x);
		return instance;
	}
};

如果我以多线程示例来使用这个类：

#include<thread>

void funa()
{
	Object& obja = Object::GetInstance(10);
	cout << "obja " << &obja << endl;
}
void funb()
{
	 Object& objb = Object::GetInstance(20);
	cout << "objb " << &objb << endl;
}

int main(void)
{
	thread thra(funa);
	thread thrb(funb);

	thra.join();
	thrb.join();

	return 0;
}

在构造该对象时，仍然会有标记位的产生，多线程会导致两个线程竞争初始化的资源，会导致这个对象初始化不明确。

标记位如何理解？
可以看static关键字详解.

懒汉模式

如果不希望在程序运行时就构造这个单例对象，而是在我们需要的时候才构造出来，就可使用 懒汉模式。

class Object
{
private:
	int value;
	static Object* pobj;
private:
	Object(int x = 0) : value(x) {}
	Object(const Object& obj) = delete;
	Object& operator =(const Object& obj) = delete;

public:
	static Object* GetInstance(int x)
	{
		if (pobj == nullptr)
		{
			pobj = new Object(10);
		}
		return pobj;
	}
};
Object* Object::pobj = nullptr;

但是这种模式相比刚才，不仅线程不安全，还会造成更严重的后果。

多线程示例：

#include<thread>

void funa()
{
	Object* obja = Object::GetInstance(10);
	cout << "obja " << &obja << endl;
}
void funb()
{
	Object* objb = Object::GetInstance(20);
	cout << "objb " << &objb << endl;
}

int main(void)
{
	thread thra(funa);
	thread thrb(funb);

	thra.join();
	thrb.join();

	return 0;
}

在第一次运行时，可以发现两个指针所指向的对象的地址是同一个，好像并没有造成影响。。。

但如果在类的 GetInstance()函数中让线程睡眠一会儿，会怎么样？

static Object* GetInstance(int x)
{
	if (pobj == nullptr)
	{
		// 睡眠
		std::this_thread::sleep_for(std::chrono::milliseconds(10));
		pobj = new Object(10);
	}
	return pobj;
}

运行结果：
产生了两个对象，这会导致严重后果。

解决方法： 加锁

#include<mutex>
std::mutex mtx;

static Object* GetInstance(int x)
{
	std::lock_guard<std::mutex> lock(mtx);
	if (pobj == nullptr)
	{
		std::this_thread::sleep_for(std::chrono::milliseconds(10));
		pobj = new Object(10);
	}
	return pobj;	
}

运行示例：
可以看出，不管程序运行多少次，两个指针都指向同一个对象。

总结

1. 线程安全模式是因为 对象直接在数据区构造，不管如何使用，其位置都是固定的；
2. 饥汉模式也是在数据区构造对象，位置固定，其中的麻烦是在多线程下构造时，会导致存储的值不明确。 比懒汉模式强的一点是不会在堆区构造。
3. 而懒汉模式使用 new来构造的对象，分布在堆区不同位置，所以不安全，需要加锁。