单例模式的懒汉模式和饿汉模式

懒汉模式

懒汉模式在第一次用到类实例的时候才会去实例化，就是不到调用getInstance函数时，这个类的对象是一直不存在的。懒汉本身是线程不安全的。

#include <iostream>
using namespace std;
 
// version 1.0
class Singleton
{
private:
	static Singleton* instance;
private:
	Singleton() {};
	~Singleton() {};
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
public:
	static Singleton* getInstance();
};
 
// init static member
Singleton* Singleton::instance = NULL;
 
Singleton *Singleton::GetSingleton(){
    if(instance == nullptr){//判断是不是第一次使用
        instance = new Singleton;
    }
    return single;
}
 

int main()
{
	singleton* a1 = singleton::GetInstance();
	return 0;
}

懒汉模式的singleton类有以下特点：

1. 他有一个指向唯一实例的静态指针，并且是私有的。
2. 它有一个公有的函数，可以获取这个唯一的实例，并且在需要的时候创建该实例。
3. 它的构造函数是私有的，这样就不能从别处创建该类的实例。

饿汉模式

饿汉模式在单例类定义的时候（即在main函数之前）就进行实例化。因为main函数执行之前，全局作用域的类成员静态变量m_Instance已经初始化，故没有多线程的问题。

#include <iostream>
#include <process.h>
#include <windows.h>
using namespace std;
 
class Singleton
{
private:
	static Singleton* instance;
private:
	Singleton() {};
	~Singleton() {};
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
public:
	static Singleton* getInstance();
};

// 饿汉模式的关键：定义即实例化
Singleton* Singleton::instance = new Singleton;
 
Singleton*Singleton::GetSingleton(){
    // 不再需要进行实例化
    //if(instance == nullptr){
    //    instance = new Singleton;
    //}
    return single;
}

int main()
{
	singleton* a1 = singleton::getinstance();
	return 0;
}

线程安全的懒汉模式

在多线程环境下，懒汉模式的上述实现方式是不安全的，原因在于在判断instance是否为空时，可能存在多个线程同时进入if中，此时可能会实例化多个对象。于是出现了二重锁的懒汉模式，实现代码如下：

#include <iostream>
using namespace std;
 
class Singleton
{
private:
	static Singleton* instance;
private:
	Singleton() {};
	~Singleton() {};
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
public:
	static Singleton* getInstance();
	static mutex i_mutex;//锁
};
 
 //类外初始化，将唯一指向实例的指针初始化为nullptr
Singleton* Singleton::instance = nullptr;
mutex Singleton::i_mutex;

Singleton *Singleton::GetSingleton(){
	//双重锁模式
	//因为获取锁是很浪费时间的，因此先判断single是否为空，如果为空则进入，不为空说明已经存在实例，直接返回。
	if (instance == nullptr){
		//进入后加锁
		i_mutex.lock();
		//再判断一次，因为可能有多个线程在lock处等待，一个线程成功之后，会将single设置为非空，这样下个线程就算拿到lock资源，再进去发现指针非空就离开了。
		if (instance == nullptr){
				instance = new lhsingleClass();
			}
		i_mutex.unlock();//解锁
	}
	return instance ;
}
 
int main()
{
	singleton* a1 = singleton::GetInstance();
	system("pause");
	return 0;
}

此代码共进行了两次判断：

• 先判断是否为空，如果为空则进入，不为空说明已经存在实例，直接返回。
• 再判断一次，因为可能有多个线程在lock处等待，一个线程成功之后，会将single设置为非空，这样下个线程就算拿到lock资源，再进去发现指针非空就离开了。