C++ 几种单例模式的写法

这段时间在做一个服务器的重构项目，其中有几个类需要用到单例。整理几种写法，如下。欢迎各位提出意见，或者更好的写法.

1：标准实现

class Singleton{
private:
Singleton(){};
virtual ~Singleton(){};
public:
Singleton *Instance();
protect:
static Singleton *_instance;
};
//Singleton.h

Singleton *Singleton::instance()
{

if(NULL == _instance){
_instance = new Singleton();
}
return _instance;
}
//Singleton.cpp

存在问题：
①：单例对象的资源无法被回收
②：非线程安全，如果两个或者多个线程同时访问Singleton::instance()很可能会内存泄露

--------------------------------------------------------------------------------------------

2：多线程模式下，单例对象生存周期等于进程生存周期的写法。

class Singleton{
public:
static Singleton *instance();
private:
Singleton();
virtual ~Singleton();
Singleton(const Singleton&){};
Singleton& operator=(const Singleton&){};
private:
static Singleton m_instance;
};
//Singleton.h

Singleton Singleton::m_instance;

Singleton::Singleton()
{
printf("contructure funcation\n");
}

Singleton::~Singleton()
{
printf("deconstructure funcation\n");
}

Singleton *Singleton::instance()
{
return &m_instance;
}
//Singleton.cpp

这种方式实现的原理是，静态数据成员在初始化数据段，在进程开始的时候就被加载，在进程结束的时候被释放。instance()函数仅仅返回指向这个对象的指针，所以多线程访问是不会出问题的。但这种写法有个问题，因为instance()返回了类里面数据成员的真实地址，这毕竟不是好的做法。

另一种写法

class Singleton{
public:
static Singleton *instance();
private:
Singleton();
virtual ~Singleton();
Singleton(const Singleton&){};
Singleton& operator=(const Singleton&){};
private:
class CGarbo{
public:
~CGarbo()
{
if(Singleton::m_pInstance){
delete m_pInstance;
}
}
};
private:
static Singleton *m_pInstance;
static CGarbo Garbo;
};
//Singleton.h

Singleton::CGarbo Singleton::Garbo;
Singleton* Singleton::m_pInstance = new Singleton();

Singleton::Singleton()
{
printf("contructure funcation\n");
}

Singleton::~Singleton()
{
printf("deconstructure funcation\n");
}

Singleton* Singleton::instance()
{
return m_pInstance;
}
//Singleton.cpp

这种写法在单例类里面嵌套的一个类，它只实现了一个析构函数，然后在单例类里面定义了它的一个静态数据成员。它唯一的作用就是在程序结束时，由系统调用它的析构函数，从而达到释放单例对象的目的。功能上已经完全实现了，唯一的不好可能就是看起来不是太爽。

3：多线程模式，要求单例对象可以随时被创建随时可以被释放的写法(linux)

#ifndef __MUTEX_H__
#define __MUTEX_h__
#include <pthread.h>

class Mutex{
private:
pthread_mutex_t m_mutex;
public:
Mutex();
virtual ~Mutex();
private:
Mutex(const Mutex&){};
Mutex& operator=(const Mutex&){};
public:
int lock();
int unlock();
int trylock();

};
#endif //__MUTEX_H__
//Mutex.h

#include "Mutex.h"

Mutex::Mutex()
{
pthread_mutex_init(&m_mutex, NULL);
}

Mutex::~Mutex()
{
pthread_mutex_destroy(&m_mutex);
}

int Mutex::lock()
{
return  pthread_mutex_lock(&m_mutex);
}

int Mutex::unlock()
{
return pthread_mutex_unlock(&m_mutex);
}

int Mutex::trylock()
{
return pthread_mutex_trylock(&m_mutex);
}
//Mutex.cpp

//单例类
#ifndef __SINGLETON_H__
#defile __SINGLETON_H__
#include "Mutex.h"
class Singleton{

public:
static Singleton *instance();
static void destroy();

private:
Singleton();
virtual ~Singleton();
Singleton(const Singleton&){};
Singleton& operator=(const Singleton&){};

private:
static Singleton *m_pInstance;
static Mutex m_Mutex;
};
#endif //__SINGLETON_H__
//Singleton.h

Singleton* Singleton::m_pInstance = NULL;
Mutex Singleton::m_Mutex;

Singleton::Singleton()
{
//do something
}

Singleton::~Singleton()
{
//do something
}

Singleton* Singleton::instance()
{
if(NULL == m_pInstance){
m_Mutex.lock();
if(NULL == m_pInstance){
m_pInstance = new Singleton();
}
m_Mutex.unlock();
}
return m_pInstance;
}

void Singleton::destroy()
{
if(m_pInstance){
m_Mutex.lock();
if(m_pInstance){
delete m_pInstance;
m_pInstance = NULL;
}
m_Mutex.unlock();
}
}
//Singleton.cpp