谈谈单例模式

河边一枝柳

发布于 2021-09-24 10:27:30

3780

发布于 2021-09-24 10:27:30

文章被收录于专栏：一个程序员的修炼之路

提前祝各位中秋节快乐！

单例模式是一个很常见的设计模式，也广泛应用于程序开发。其具有如下特点:

一个类只有一个实例化对象
全局可以使用

那么有人要问，那我不就定义一个类，程序只初始化一个全局的实例就好了吗？没错，这样是可以的。但是我们都知道程序会经过多人的接手维护和开发，比如第N个接手程序的时候，并不知道这个类定义的时候只能初始化一个实例，然后又实例化了新的对象，则可能会造成意想不到的场景。那么这时候就要提到防御性编程，个人认为单例模式的实现也是防御性编程的一种方式，让这个类保证只有一个实例化对象，并且如果试图构造多个对象的时候，在程序的编译期报错。题外话，这也是为什么本人在进行一些稍大规模开发的时候，只会去选择强类型语言，而不会选择弱类型语言的原因，强类型语言会在编译期间帮我们避免很多运行时可能产生的的Bug。

本文我们将探讨如下内容:

单例模式的基本实现：包含单例模式的实现，线程安全，以及生命周期等
单例模式的模板实现，多模块调用单例存在的问题

单例模式的基本实现

在程序开发中，比较常见的单例就是程序启动的相关配置信息了。比如我们定义一个SingletonConfig类。注意这个类有如下特点：

私有的构造函数, 拷贝构造函数，以及operator=, 保证其不能够在类的外部进程对象构造，拷贝等操作。
GetInstance是一个公有的静态成员函数，用来构造这个类唯一的实例对象m_objConfig, 并且返回给使用者。

我们来看下代码实现：

class SingletonConfig
{
public:
  static SingletonConfig * GetInstance()
{
    if (m_objConfig =  = nullptr)
      m_objConfig = new SingletonConfig;
    return m_objConfig;
  }

private:
  SingletonConfig() { ; };
  SingletonConfig(const SingletonConfig&) { ; };
  SingletonConfig& operator= (const SingletonConfig&) { ; };
  
private:
  static SingletonConfig *m_objConfig;
};

SingletonConfig* SingletonConfig::m_objConfig = nullptr;

这也就是单例模式的基本实现了，然后我们需要考虑的就是单例的模式的生命周期问题，单例的实例何时创建？何时销毁？

单例模式生命周期

单例创建的时机

根据单例的创建时间，可以分为饿汉模式和懒汉模式。上一节所展示的代码则是懒汉模式: 当你的应用程序在需要调用GetInstance()方法的时候才创建实例化的对象，类似于懒加载。这种方式的好处在于，有一些单例模式的实例，可能在整个进程的声明周期内可能不一定用到。那么这种懒汉模式就省去了不必要的资源创建过程。

饿汉模式一般的实现方式为，在进程或者模块加载的时候就会创建全局的实例。比如将上述单例模式修改为。像这种进程启动必须要使用的单例对象，使用饿汉模式实现比较简单。

class SingletonConfig
{
public:
  static SingletonConfig * GetInstance()
{
    return m_objConfig;
  }

private:
  SingletonConfig() { ; };
  SingletonConfig(const SingletonConfig&) { ; };
  SingletonConfig& operator= (const SingletonConfig&) { ; };
  
private:
  static SingletonConfig *m_objConfig;
};

SingletonConfig* SingletonConfig::m_objConfig = new SingletonConfig;

综合来看什么情况下该使用饿汉模式，什么情况下该使用懒汉模式呢？个人认为大多数实现的场景下应该使用懒汉模式，其更加灵活，可以自己定义单例对象的创建时间；对于初始化对象时间比较长的单例，可以在进程启动的时候手动的调用GetInstance()方法来完成初始化，避免在服务过程中导致第一个初始化示例对象的任务处理速度变慢。

单例释放的时机

接下来查看，那么单例模式应该何时释放其资源呢？一般情况下当进程退出的时候，一般的资源也都会随之释放，大多数场景单例模式即使不手动去调用析构函数也不会带来很大的问题。但是有一些场景想在进程退出前把资源处理完善，比如这个单例对象有内存中的内容需要刷新到磁盘。那么有两种方法，一种是全局static对象由进程退出的时候调用析构函数，另一种是让单例使用者自己进行析构函数调用。先说说全局static对象，一种是直接在类成员里面定义一个static成员，或者是在GetInstance()中定义一个static单例对象，比如：

class SingletonConfig
{
public:
  static SingletonConfig * GetInstance()
{
    static SingletonConfig objConfig;
    return &objConfig;
  }
  virtual ~SingletonConfig()
  {
    std::cout << "~SingletonConfig()" << std::endl;
  }
private:
  SingletonConfig() { ; };
  SingletonConfig(const SingletonConfig&) { ; };
  SingletonConfig& operator= (const SingletonConfig&) { ; };
};

这种方法在程序退出的时候，将会调用SingletonConfig的析构函数，看下汇编，可以看到利用atexit注册了一个方法，这个方法中会调用SingletonConfig的析构函数，并且在程序退出的时候执行。

如果想自己去控制单例模式的释放时间可以实现如下，在合适的时机调用ReleaseInstance方法去释放单例对象。

class SingletonConfig
{
public:
  static SingletonConfig * GetInstance()
{
    if (m_objConfig == nullptr)
      m_objConfig = new SingletonConfig;
    return m_objConfig;
  }

  static void ReleaseInstance()
{
    if (m_objConfig)
    {
      delete m_objConfig;
      m_objConfig = nullptr;
    }
  }

  virtual ~SingletonConfig()
  {
    std::cout << "~SingletonConfig()" << std::endl;
  }
private:
  SingletonConfig() { ; };
  SingletonConfig(const SingletonConfig&) { ; };
  SingletonConfig& operator= (const SingletonConfig&) { ; };

private:
  static SingletonConfig* m_objConfig;
};
SingletonConfig* SingletonConfig::m_objConfig = nullptr;

这里我要留一个问题给读者如果有两个单例模式SingletonA和SingletonB, 他们都采用static的方式实现单例，那么如果SingletonA调用了SingletonB，有没有可能产生什么问题？如果有如何避免这个问题？如果不知道的可以看看书籍**<<C++设计新思维>>中的凤凰单例，意味着涅槃重生。** 如果对这个理解了，那对单例模式的生命周期的理解也差不多到位了。

线程安全

如果是如下方式使用static对象方式实现的单例模式，在C++ 11之前是非线程安全的，而在C++ 11之后是线程安全的。

static SingletonConfig * GetInstance()
{
  static SingletonConfig objConfig;
  return &objConfig;
}

但如果不使用static对象，采用下述方式，那么在单例对象还没初始化的时候，当多线程同时调用GetInstance可能会出现线程安全问题，导致创建了多个SingletonConfig。

static SingletonConfig * GetInstance()
{
  if (m_objConfig == nullptr)
    m_objConfig = new SingletonConfig;
  return m_objConfig;
}

而一般的实现如下:

使用std::lock_guard去多线程保证互斥
双重的m_objConfig == nullptr检查，第一次是为了效率，当单例对象已经在的时候，就不需要互斥锁了；第二次是进入锁范围之后，要查看下，是否有其他线程已经创建了单例对象，如果还没有创建才进行创建。

class SingletonConfig
{
public:
  static SingletonConfig * GetInstance()
{
    if (m_objConfig == nullptr)
    {
      std::lock_guard<std::mutex> guard(m_mutex);
      if (m_objConfig == nullptr)
      {
        m_objConfig = new SingletonConfig;
      }
    }
    return m_objConfig;
  }

  static void ReleaseInstance()
{
    if (m_objConfig)
    {
      delete m_objConfig;
      m_objConfig = nullptr;
    }
  }

  virtual ~SingletonConfig()
  {
    std::cout << "~SingletonConfig()" << std::endl;
  }
private:
  SingletonConfig() { ; };
  SingletonConfig(const SingletonConfig&) { ; };
  SingletonConfig& operator= (const SingletonConfig&) { ; };

private:
  static SingletonConfig* m_objConfig;
  static std::mutex       m_mutex;
};
SingletonConfig* SingletonConfig::m_objConfig = nullptr;
std::mutex SingletonConfig::m_mutex;

单例模式的模板实现以及可能的问题

在网上或者一些书上，会使用模板去实现通用的单例模式，大致如下:

template<typename T>
class  CommonSingleton
{
public:
  static T* GetInstance()
{
    if (m_objSingle == nullptr)
    {
      std::lock_guard<std::mutex> guard(m_mutex);
      if (m_objSingle == nullptr)
      {
        m_objSingle = new T;
      }
    }
    return m_objSingle;
  }

  static void ReleaseInstance()
{
    if (m_objSingle)
    {
      delete m_objSingle;
      m_objSingle = nullptr;
    }
  }

private:
  CommonSingleton() { ; };
  CommonSingleton(const CommonSingleton&) { ; };
  CommonSingleton& operator= (const CommonSingleton&) { ; };

private:
  static T* m_objSingle;
  static std::mutex       m_mutex;
};

template<typename T>
T* CommonSingleton<T>::m_objSingle = nullptr;

template<typename T>
std::mutex CommonSingleton<T>::m_mutex;

如果有一个类需要单例模式，比如TestClass，则调用方式如下:

CommonSingleton<TestClass>::GetInstance();

以上的模板实现大家注意到了没，这个实例化的对象有一个没有参数的构造函数，如果一个类是必须有参数的构造函数呢？这个时候其实可以借助C++ 11 中的可变参数的完美转发。具体实现读者可以思考下，如果不清楚的可以参考《深入应用C++11代码优化及工程级应用》中的改进单例模式这一章节。

不过本人认为这一种的模板化实现，并不是一个特别好的方案，我也并不会优先选择模板化的单例模式实现，主要有两点原因:

模板参数接受的类，可以是这种：默认暴露给用户，可以构造，拷贝，赋值的类，这样便可以重新创造多个对象。这种方式缺乏了本人所理解的防御性编程的思路。
当使用模板实例化的时候，同一种模板参数的类，在多个不同的模块中其实都会有自己的实例化对象。比如有A和B两个模块，并且均调用了CommonSingleton<TestClass>::GetInstance();, 其实在A和B中存在不同的TestClass对象，这样也违背了一个程序一个实例化对象的初衷。当然只有一个工程不影响。对于非模板的实现，一般将单例实现的类从模块导出，将实现放在.cpp文件中，那么这种多个工程对同一种单例的类只会有一个实例化对象。个人觉得这一点比较重要，需要读者多多体会。