c++单例模式(线程安全，没有内存泄漏)

我们都很清楚一个简单的单例模式该怎样去实现：构造函数声明为private或protect防止被外部函数实例化，内部保存一个private static的类指针保存唯一的实例，实例的动作由一个public的类方法代劳，该方法也返回单例类唯一的实例。单例大约有两种实现方法：懒汉与饿汉。
懒汉：故名思义，不到万不得已就不会去实例化类，也就是说在第一次用到类实例的时候才会去实例化，节省内存。
饿汉：饿了肯定要饥不择食。所以在单例类定义的时候就进行实例化。浪费内存
特点与选择：
由于要进行线程同步，所以在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。
在访问量较小时，采用懒汉实现。这是以时间换空间。
1.懒汉（线程不全，内存泄漏）
class singleton
{
private://protect也可以
static singleton* p;  
singleton(){}
public:
    static singleton* instance();
singleton* instance()
{
    if (p == NULL)
        p = new singleton();
    return p;
}
}；


GetInstance()使用懒惰初始化，也就是说它的返回值是当这个函数首次被访问时被创建的。
这是一种防弹设计——所有GetInstance()之后的调用都返回相同实例的指针：但这是一个完美的实现吗？不！该方法是线程不安全的，考虑两个线程同时首次调用instance方法且同时检测到p是NULL值，则两个线程会同时构造一个实例给p，这是严重的错误！
而且new出来的东西没有析构，会内存泄漏。
线程不安全，怎么办呢？最直观的方法：加锁。
2.加锁的经典懒汉实现：（会内存泄露），没有析构函数，指针指向空间没删除。
class singleton
{ 
private:
static singleton* p; 
singleton()
    {
        pthread_mutex_init(&mutex);
    }
public:
    static pthread_mutex_t mutex;
    static singleton* initance();
singleton* initance()
{ 
   if (p == NULL) 
{
   pthread_mutex_lock(&mutex); 
      if (p == NULL) 
       {
           p = new singleton(); 
           pthread_mutex_unlock(&mutex); 
       } 
return p;
}
};


3.内部静态变量的懒汉实现（内存泄漏，拷贝有问题）
使用静态局部变量的方法来产生单例，需要注意的是，C++0X以后，要求编译器保证内部静态变量的线程安全性，因此在支持c++0X的编译器中这种方法可以产生线程安全的单例模式，然而在不支持c++0X的编译器中，这种方法无法得到保证。此方法也很容易实现，在instance函数里定义一个静态的实例，也可以保证拥有唯一实例，在返回时只需要返回其指针就可以了。
 使用局部静态变量，非常强大的方法，完全实现了单例的特性，而且代码量更少，也不用担心单例销毁的问题。但使用此种方法也会出现问题，当如下方法使用单例时问题来了，
Singleton singleton = Singleton :: GetInstance();
这么做就出现了一个类拷贝的问题，这就违背了单例的特性。产生这个问题原因在于：编译器会为类生成一个默认的构造函数，来支持类的拷贝。
 
class singleton
{
private:
    singleton()
    {
        pthread_mutex_init(&mutex);
    }
public:
    static pthread_mutex_t mutex;
    static singleton* initance();
singleton* initance()
{
    pthread_mutex_lock(&mutex);
    static singleton obj;
    pthread_mutex_unlock(&mutex);
    return &obj;
}
};


4.饿汉实现（线程安全，会内存泄漏）
　　为什么我不讲“线程安全的饿汉实现”？因为饿汉实现本来就是线程安全的，不用加锁！ classloder机制避免了多线程的同步问题。（会内存泄漏），new的东西没释放
class singleton
{
private:
static singleton*p;  
singleton() {}
public:
static singleton* initance();
singleton* p = new singleton（）;//饿汉的体现，直接实例化，也就不存在线程不安全了。
singleton* initance()
{
    return p;
}
};


5.饿汉，线程安全，不会内存泄漏
class singleton
{
private:
static singleton*p;  
singleton() {}
~CSingleton()
  {
   if (p== NULL) { return ;}
   delete P;
   P = NULL;
   }
public:
    static singleton* initance();
    singleton* p = new singleton（）;//饿汉的体现，直接实例化，也就不存在线程不安全了。
    singleton* initance()
    {
      return p;
    }
};