设计模式那点事--单例模式

       单例模式，也许是我们平常用得和接触比较多的设计模式了，很多朋友在企业面试的时候都会被问到。说起这里，我想起了当初毕业面试时那张口结舌的丑态，心中总会多少有些愧疚，痛恨自己基础实在是糟糕。好吧，让我们回到主题，什么是单例模式呢？

       概念：

      单例模式（Singleton），它保证了一个类仅有一个实例，并提供一个访问它的全局访问点。

      在C++中，你可以直接用一个全局变量做到这一点，但这样的代码存在着缺陷，特别是在多线程程序中。使用全局对象能够保证方便地访问实例，但是不能保证只声明一个对象——也就是说除了一个全局实例外，仍然能创建相同类的本地实例。

      类图：

      作用：

      1、控制资源的使用，通过线程同步来控制资源的并发访问；
      2、控制实例产生的数量，达到节约资源的目的；
      3、作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信。

      应用场景：

      1、系统的日志输出，因为日志文件都是共享并处于打开状态，因此最好用一个实例去操作，不应该循环关闭打开；

      2、Windows的Recycle Bin（回收站）；

      3、MODEM的联接需要一条且只需要一条电话线；

      4、Windows的Task Manager（任务管理器），你永远无法打开两个以上任务管理器；

      5、一台PC连一个键盘等等。

      代码：

class CSingleton
{
//其他成员
public:
static CSingleton* GetInstance()
{
      if ( m_pInstance == NULL )  //判断是否第一次调用
        m_pInstance = new CSingleton();
        return m_pInstance;
}
private:
    CSingleton(){};
    static CSingleton * m_pInstance;
};

      从代码中可以看出单例模式的特点：

     1、构造函数是私用private的，这样就不能在别处创建此类的实例；

     2、有一个指向唯一实例的静态指针m_pInstance，类型也是private；

     3、它有一个公有的GetInstance函数，可以获取这个唯一的实例，并且只会在第一次调用的时候创建该实例（懒惰初始化），这种防弹设计，所有GetInstance函数返回的都是相同实例的指针。（注意，要想返回静态static的实例指针m_pInstance，GetInstance返回值也要声明为static。）

     测试代码：

static void main()
{
    CSingleton *s1 = CSingleton.GetInstance();
    CSingleton *s2 = CSingleton.GetInstance();
    if (s1 == s2)
    {
        Cout<<”两个对象是相同的实例！”<<endl;
    }
}

       结果：打印出“两个对象是相同的实例！”。

       代码分析：

       1、m_pInstance指向的空间什么时候释放呢？

        可以在程序结束时调用GetInstance()，并对返回的指针掉用delete操作。这样做可以实现功能，但容易出错。因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。
        一个妥善的方法是让这个类自己知道在合适的时候把自己删除，或者说把删除自己的操作挂在操作系统中的某个合适的点上，使其在恰当的时候被自动执行。
        我们知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。代码如下：

class CSingleton
{
//其他成员
public:
static CSingleton* GetInstance()
{
      if ( m_pInstance == NULL )  //判断是否第一次调用
        m_pInstance = new CSingleton();
      return m_pInstance;
}
private:
    CSingleton(){};
    static CSingleton * m_pInstance;
    class CGarbo //它的唯一工作就是在析构函数中删除CSingleton的实例
   {
        public:
            ~CGarbo()
            {
                if( CSingleton::m_pInstance )
                  delete CSingleton::m_pInstance;
            }
    }
    //定义一个静态成员，程序结束时，系统会自动调用它的析构函数
    Static CGabor Garbo; 
}；

        类CGarbo被定义为CSingleton的私有内嵌类（无权限控制符，默认为private），以防该类被在其他地方滥用。
        程序定义了CGabor的一个静态成员Garbo，程序运行结束时，系统会自动调用CSingleton的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。

        从此以后，我们再也不必关心对象的释放，再也不用对对象的释放做任何的操作了。

       2、多线程下的单例模式应该如何注意？

       以上的单例模式不是线程安全的，所以我们要用多线程的同步方法和双重锁定来改写以上的单例模式。代码如下

//线程同步类
class LockSingleton
{
public: 
    inline LockSingleton() 
  { 
     m_hMutex=CreateMutex(NULL,FALSE,NULL); 
  } 
    inline ~LockSingleton() { CloseHandle(m_hMutex); } 
    inline void Lock() { WaitForSingleObject(m_hMutex, INFINITE); } 
    inline void Unllock() { ReleaseMutex(m_hMutex); } 
private: 
    HANDLE m_hMutex;
};
 
class CSingleton
{
//其他成员
public:
static CSingleton* GetInstance()
{
      if ( m_pInstance == NULL )  //判断实例是否存在，不存在加锁处理
      {
          Lock();
          if ( m_pInstance == NULL )  //判断是否第一次调用
          {
              m_pInstance = new CSingleton();
          } 
          Unlock();
      }
      return m_pInstance;
}
private:
    CSingleton(){};
    static CSingleton * m_pInstance;
    class CGarbo //它的唯一工作就是在析构函数中删除CSingleton的实例
    {
        public:
            ~CGarbo()
            {
                if( CSingleton::m_pInstance )
                  delete CSingleton::m_pInstance;
            }
    }
    //定义一个静态成员，程序结束时，系统会自动调用它的析构函数
    Static CGabor Garbo; 
}；

        这样，通过第一层的判断，我们不用让线程每次都加锁，而只是在实例未被创建的时候再加锁处理；同时也能保证多线程的安全。这种做法被称为Double-Check-Locking（双重锁定）。

        以上便是我对单例模式的理解。在这过程中，我参考了很多资料，学习了很多知识，对单例模式有了更深的体会。

        “我要一步一步往上爬，在最高点乘着叶片往前飞。小小的天流过的泪和汗，总有一天我有属于我的天。”--《蜗牛》