设计模式 -- 单例模式

单例模式就是指一个类只能被实例化一次。

经典实现：

class A{
public:	
	static A *a;
	
	static A* getInstance(){
		if(a==nullptr){
			a = new A;
		}
		return a;
	}
private:	
	A(){
		cout<<"A()"<<endl;
	}
	

};

A *A::a==nullptr;

类A的唯一实例用静态变量存储，用getInstance创建和取得，第一次调用getInstance的时候用来创建。此方法可能存在线程安全性的问题。
当线程A执行到if(a==nullptr) 后，此时线程b开始执行调用getInstance，判断a==nullptr，同样会new一个A出来，此时两个线程创建了两个实例。

线程安全的单例

加锁

可以采用锁机制，当调用getInstance时加锁，离开函数后解锁，但这样的话会降低性能，因为不能并发调用此函数了，而且只有第一次调用getInstance创建实例的时候需要加锁，第一次之后根本没有必要加锁。
MutexLockGuard的使用见：
https://blog.csdn.net/littleflypig/article/details/89189251

class A{
public:	
	static A *a;    //声明
	static A* getInstance(){
		MutexLockGuard(mutex);
		if(a==nullptr){
			a = new A;
		}
		return a;
	}
private:	
	A(){
		cout<<"A()"<<endl;
	}
};
A A::a;  //定义

可以采用下面方法：

“急切”创建实例

class A{
public:	
	static A *a;    //声明
	static A* getInstance(){
		return a;
	}
private:	
	A(){
		cout<<"A()"<<endl;
	}
};
A A::a = new A;  //定义并初始化

在初始化的时候就创建实例，而不是等到调用函数是再创建（延迟创建）。这种方法缺点是不能节省资源，即使用不到也会创建。

双重检查加锁（Double checked locking，DCL）

用volatile来保证读取内存而不是缓存，但是c++的volatile不知道是不是实现了这个功能。。。

class A{
public:	
	volatile static A *a;    //声明
	static A* getInstance(){
		if(a==nullptr){
			MutexLockGuard(mutex);
			if(a==nullptr){
				a = new A;
			}		
		}
		return a;
	}
private:	
	A(){
		cout<<"A()"<<endl;
	}
};
A A::a;  //定义

用pthread_once保证

template <typename T>
class Singleton : noncopyable{
public:
	static T& getInstance(){
		pthread_once(&once_,&Singleton::init);
		return *value_;
	}
private:
	static void init(){
		value = new T();
	}
private:
	static pthread_once_t once_;
	static T* value_;
}

template <typename T>
pthread_once_t Singleton<T>::once_ = PTHREAD_ONCE_INIT;
template <typename T>
T* Singleton<T>::value_ = nullptr;

参考：headfirst设计模式 muduo网络库