C++设计模式----单例模式（1）

单例设计模式

    单例设计模式是应用最多的一种设计模式，它要求每个类有且只能有一个实例对象。用C++设计一个单例模式的方法如下：

1. 一个类只允许创建唯一的对象，构造函数声明为私有；这样就保证了不能随意构造一个对象。
2. 将拷构造函数与等号运算符声明为私有，并不提供他们的实现；即禁止对象被拷贝。
3. 在类中声明一个静态的全局访问接口（静态成员变量）。
4. 声明一个静态的私有实例化指针。

创建方式

1. 饿汉式：单例对象无论用或不用，程序启动即创建。
2. 懒汉式：单例对象在用的时候在创建，不用即销毁。

简单单例模式的实现

#include <iostream>
using namespace std;
 
class Singleton
{
    public:
        static Singleton *GetInstance()
        {
            if (m_Instance == NULL )
            {
                m_Instance = new Singleton ();
            }
            return m_Instance;
        }
     
        static void DestoryInstance()
        {
            if (m_Instance != NULL )
            {
                delete m_Instance;
                m_Instance = NULL ;
            }
        }
        // This is just a operation example
        int GetTest()
        {
            return m_Test;
        }
     
    private:
        Singleton()
        {
            m_Test = 10;
        }
        static Singleton *m_Instance;
        int m_Test;
};
Singleton *Singleton::m_Instance = NULL;
 
int main()
{
    Singleton *singletonObj=Singleton::GetInstance();
    
    cout<<singletonObj->GetTest()<<endl;
    Singleton::DestoryInstance();
    return 0;
}

多线程下单例模式的实现

#include <iostream>
using namespace std;
 
class Singleton
{
    public:
        static Singleton *GetInstance()
        {
            if (m_Instance == NULL )
            {
                Lock(); // 加锁
                if (m_Instance == NULL )
                {
                    m_Instance = new Singleton ();
                }
                UnLock(); // 解锁
            }
            return m_Instance;
        }
     
        static void DestoryInstance()
        {
            if (m_Instance != NULL )
            {
                delete m_Instance;
                m_Instance = NULL ;
            }
        }
     
        int GetTest()
        {
            return m_Test;
        }
     
    private:
        Singleton()
        {
            m_Test = 0;
        }
        static Singleton *m_Instance;
        int m_Test;
};
 
Singleton *Singleton ::m_Instance = NULL;
 
int main()
{
    Singleton *singletonObj = Singleton ::GetInstance();
    cout<<singletonObj->GetTest()<<endl;
    Singleton ::DestoryInstance();
 
    return 0;
}

代码说明：

1. 为何要使用双重检查锁定(两次检查null)呢？
   有两个线程同时到达，即同时调用 GetInstance() ，此时由于 m_Instance == null ，所以很明显，两个线程都可以通过第一重的 m_Instance == null ，进入第一重 if 语句后，由于存在锁机制，所以会有一个线程进入 lock 语句并进入第二重 m_Instance == null ，而另外的一个线程则会在 lock 语句的外面等待。而当第一个线程执行完 new Singleton （）语句后，便会退出锁定区域，此时，第二个线程便可以进入 lock 语句块，此时，如果没有第二重 m_Instance == null 的话，那么第二个线程还是可以调用 new Singleton （）语句，这样第二个线程也会创建一个 SingleTon实例，这样也还是违背了单例模式的初衷的，所以这里必须要使用双重检查锁定

2. 如果我去掉第一重 m_Instance == null ，程序还是可以在多线程下完好的运行的
   考虑在没有第一重 m_Instance == null 的情况下，当有两个线程同时到达，此时，由于 lock 机制的存在，第一个线程会进入 lock 语句块，并且可以顺利执行 new SingleTon（），当第一个线程退出 lock 语句块时， singleTon 这个静态变量已不为 null 了，所以当第二个线程进入 lock 时，还是会被第二重 m_Instance == null 挡在外面，而无法执行 new Singleton（），所以在没有第一重 m_Instance == null 的情况下，也是可以实现单例模式的？那么为什么需要第一重 singleton == null 呢？这里就涉及一个性能问题了，因为对于单例模式的话，new SingleTon（）只需要执行一次就 OK 了，而如果没有第一重 m_Instance == null 的话，每一次有线程进入GetInstance（）时，均会执行锁定操作来实现线程同步，这是非常耗费性能的，而如果我加上第一重 m_Instance == null 的话，那么就只有在第一次，也就是 m_Instance ==null 成立时的情况下执行一次锁定以实现线程同步，而以后的话，便只要直接返回 Singleton 实例就 OK 了而根本无需再进入 lock 语句块了，这样就可以解决由线程同步带来的性能问题了。但是，如果进行大数据的操作，加锁操作将成为一个性能的瓶颈；为此，一种新的单例模式的实现也就出现了。