单例模式的两种线程安全并且效率的写法

#include<iostream>
#include<assert.h>
#include<mutex>
#include<Windows.h>

using namespace std;

mutex mtx;
//懒汉模式
template<class T>
class singleton
{
public:
static singleton* GetSingleton()
{
//双重判断是为了效率，避免多次加锁；
if (single == NULL)
{
std::lock_guard<mutex> lck(mtx);//在离开作用域后自动释放锁
//mtx.lock();//为了避免在加锁和解锁直接出现异常比如说new，不采用这种方式而采用RAII
if (single == NULL)
//这个判断实际只会执行一两次
{
//single = new singleton;
//上面的语句偶尔会在编译器的优化下出现问题；
singleton* tmp = new singleton;
MemoryBarrier();//内存栅栏
single = tmp;
}
//mtx.unlock();
}
return single;
}
private:
singleton()
:_data(new T)
{}
singleton(const singleton&);
singleton operator=(const singleton&);

static singleton* single;
private:
T _data
};

template<class T>
singleton::singleton* single = NULL;

#include<iostream>
#include<assert.h>
#include<mutex>
#include<Windows.h>

using namespace std;
//饿汉模式
singleton<T>::GC gc;

template<class T>
class singleton
{
public:
//singleton* GetSingleton()
//{
//  return &single;
//}

//或者这样的实现,外面的staic指针就没必要了
static singleton GetSingleton()
{
static singleton single;//静态变量初始化在main函数之前，不存在线程安全
return &single;
}

static void DelSingleton()//其实大多数情况下不需要销毁单例对象,除非单例对象里有一些数据库链接，文件描述符等；
{
delete single;
single = NULL;
}

//在全局定义一个GC类对象；用这样的方式保证程序结束后释放单例对象
class GC
{
~GC()
{
DelSingleton();
}
};

private:
singleton()
:_data(new T)
{}
singleton(const singleton&);
singleton operator=(const singleton&);

static singleton* single;
private:
T _data
};

template<class T>
singleton::singleton* single = new singleton;