设计模式-单例模式

饿汉式单例模式：还没有获取实例对象，实例对象就已经产生了

class Singleton {
public:
	static Singleton* getInstance()
	{
		return &instance;
	}
	
private:
	static Singleton instance;
	Singleton()
	{

	}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
};
//静态成员变量类外初始化
Singleton Singleton::instance;

int main()
{
	Singleton *p1 = Singleton::getInstance();
	Singleton *p2 = Singleton::getInstance();
	Singleton *p3 = Singleton::getInstance();

	//如果没有私有化拷贝构造，这里会发生拷贝
	//Singleton p4 = *p1;

	cout << "p1: " << p1
		<< " p2: " << p2
		<< " p3: " << p3
		/*<< " p4: " << &p4*/ << endl;

	return 0;
}

饿汉式单例模式一定是线程安全的，因为静态成员变量在程序启动后就完成了初始化，不会有线程安全问题。但存在一些缺点，如果程序中始终没有用到该单例，并且在构造函数中又做了大量的事情，比如打开文件等等，这时无疑会影响效率。

懒汉式单例模式：唯一的实例对象，直到第一次获取它的时候，才产生

class Singleton {
public:
	static Singleton* getInstance()
	{
		if (instance == nullptr)
		{
			instance = new Singleton();
		}
		return instance;
	}
	
private:
	static Singleton *instance;
	Singleton()
	{
	}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
};
Singleton* Singleton::instance = nullptr;

int main()
{
	Singleton *p1 = Singleton::getInstance();
	Singleton *p2 = Singleton::getInstance();
	Singleton *p3 = Singleton::getInstance();

	cout << "p1: " << p1
		<< " p2: " << p2
		<< " p3: " << p3 << endl;

	return 0;
}

懒汉式解决了用到时再初始化的问题，但却不是线程安全的。
多线程环境下，构造对象时可能会出现问题：

static Singleton* getInstance()
	{
		if (instance == nullptr)
		{
			/*
			开辟内存
			构造对象
			给instance赋值
			*/
			instance = new Singleton();
		}
		return instance;
	}

比如构造对象时会经历三步，第一个线程进来发现instance为空，进行开辟内存，但还没给instance赋值，这时instance还为空，这时第二个线程也可以进入构造，函数不可重入。同时，现代计算机为了加快运行速度，构造对象和给instance赋值的操作完全可能顺序相反，这时如果第二个线程发现instance不为空，直接返回，也会发生错误，因为这时完成了赋值却还没构造。
一种解决方法是加锁：

mutex mtx;

class Singleton {
public:
	static Singleton* getInstance()
	{
		lock_guard<std::mutex> guard(mtx);
		if (instance == nullptr)
		{
			/*
			开辟内存
			构造对象
			给instance赋值
			*/
			instance = new Singleton();
		}
		return instance;
	}
	...
}

但是这种情况对于单线程又不友好，每次都要加锁，锁的粒度太大。现在将锁放在if里面

mutex mtx;

class Singleton {
public:
	static Singleton* getInstance()
	{
		if (instance == nullptr)
		{
			lock_guard<std::mutex> guard(mtx);
			/*
			开辟内存
			构造对象
			给instance赋值
			*/
			instance = new Singleton();
		}
		return instance;
	}
	...
}

这时同样存在问题，第一个线程进入if，加锁，new对象，这时第二个线程判断instance为空，进入等待锁，第一个线程new完后，第二个线程拿到锁，同样会new对象。
所以这时就要进行双重检测：

static Singleton* getInstance()
	{
		if (instance == nullptr)
		{
			lock_guard<std::mutex> guard(mtx);
			if (instance == nullptr)
			{
				/*
				开辟内存
				构造对象
				给instance赋值
				*/
				instance = new Singleton();
			}
		}
		return instance;
	}

这时便完成了线程安全的单例模式。

private:
	static Singleton *volatile instance;
	Singleton()
	{
	}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
};
Singleton*volatile Singleton::instance = nullptr;

一种更为简洁的写法是：

class Singleton {
public:
	static Singleton* getInstance()
	{
		//函数静态局部变量的初始化，在汇编指令上已经自动添加线程互斥指令了
		static Singleton instance;
		return &instance;
	}
	
private:
	Singleton()
	{
	}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
};