谈谈单例模式

提前祝各位中秋节快乐!

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

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

那么有人要问,那我不就定义一个类,程序只初始化一个全局的实例就好了吗?没错,这样是可以的。但是我们都知道程序会经过多人的接手维护和开发,比如第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;

这里我要留一个问题给读者如果有两个单例模式SingletonASingletonB, 他们都采用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代码优化及工程级应用》中的改进单例模式这一章节。

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

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

总结

单例模式除了其具有程序中单个实例化对象的特点,也具有防御式编程的思想在其中。使用中一定要注意单例模式的生命周期,以及模板实现的跨模块调用的问题。以上仅是一家之言,欢迎一起讨论。

参考

  1. <<C++设计新思维>>中的Singletons实作技术这一章节
  2. <<深入应用C++11代码优化及工程级应用>>的改进单例模式这一章节

本文分享自微信公众号 - 一个程序员的修炼之路(CoderStudyShare),作者:河边一枝柳

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2021-09-19

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 谈谈多例模式(multiton)

    在文章<<谈谈单例模式>>中介绍过单例模式, 一个类全局只会生成一个实例化的对象。而本文将从一些工程经验中,抽象出问题的场景,来谈一谈多例模式,便于还不熟悉的读...

    河边一枝柳
  • 浅谈设计模式 - 单例模式(一)

    非常简单,在创建之前,旧对对象进行了初始化,其实对于比较小的对象,这种方式在实际的使用过程中最多

    阿东
  • 图图细谈设计模式——单例模式

    图图在为面试做准备,今天图图给大家细说一番单例模式。其实最简单的是工厂模式而不是单例(工厂后续会说)

    一头小山猪
  • 浅谈JAVA设计模式之——单例模式(Singleton)

    看几个单例对象的示例代码,其中有些代码是线程安全的,有些则不是线程安全的,需要大家细细品味,这些代码也是冰河本人在高并发环境下测试验证过的。

    冰河
  • 详谈单例、饿汉、和懒汉模式

    私有构造函数保证了不能通过构造函数来创建对象实例,只能通过公有静态函数返回唯一的私有静态变量。

    李红
  • 详谈单例、饿汉、和懒汉模式

    私有构造函数保证了不能通过构造函数来创建对象实例,只能通过公有静态函数返回唯一的私有静态变量。

    李红
  • 谈谈 MVC 模式

    如何设计一个程序的结构,这是一门专门的学问,叫做"架构模式"(architectural pattern),属于编程的方法论。

    IT派
  • 谈谈SAAS模式

    什么是SAAS 软件即服务英文是Software-as-a-service的意译。国外称为SaaS,国内通常叫做软件运营服务模式,简称为软营模式。 SAAS的起...

    cloudskyme
  • 谈谈MVC模式

    1. 如何设计一个程序的结构,这是一门专门的学问,叫做"架构模式"(architectural pattern),属于编程的方法论。 MVC模式就是架构模式的一...

    ruanyf
  • 谈谈MVC模式

    1. 如何设计一个程序的结构,这是一门专门的学问,叫做"架构模式"(architectural pattern),属于编程的方法论。 MVC模式就是架构模式的一...

    MonroeCode
  • 浅谈DAO设计模式(示例)

    DAO(Data Access Object)数据访问接口。废话不多说(官方定义什么的写了也没人看?),其实就是一种数据设计范化模式,打个比方,我们写的第一个j...

    唔仄lo咚锵
  • 浅谈MVC设计模式(示例)

    (官方定义出门右转) MVC(Model View Controller)模型-视图-控制器。典型的MVC就是javabean(M)+JSP(V) + ser...

    唔仄lo咚锵
  • 浅谈设计模式 - 简单工厂模式(二)

    对于学习设计模式,我推荐:《HeadFirst设计模式》和《大话设计模式》。另外设计模式推崇学以致用。看到任何知识之前,先想想我能学到什么,带着问题去看待问题...

    阿东
  • 谈谈观察者模式和发布订阅模式

    参考学习: https://juejin.im/post/5a14e9edf265da4312808d86 https://molunerfinn.com/...

    Ewall
  • 谈谈你知道的设计模式?

    创建型模式,是对对象创建过程的各种问题和解决方案的总结,包括各种工厂模式 (Factory、Abstract Factory)、单例模式(Singleton)...

    葆宁
  • 谈谈模板方法设计模式的使用

    在项目中经常会遇到一个类的某些方法和另一个类的某些方法功能是相同的,只有部分方法是不同的。这个时候就可以使用模板方法来操作了。其实这种情况很常见:比如我们项目里...

    AWeiLoveAndroid
  • 谈谈模板方法设计模式的使用

    在项目中经常会遇到一个类的某些方法和另一个类的某些方法功能是相同的,只有部分方法是不同的。这个时候就可以使用模板方法来操作了。其实这种情况很常见:比如我们项目里...

    竹清
  • 谈谈我对设计模式的理解

    怎么讲呢?《孙子兵法》玄不玄?也玄!因为芸芸众生中能看懂悟透的人很少,能真正灵活应用的人更少!而且战争的成败受众多因素的影响,如天时、地利、人和。但你要问中国历...

    只喝牛奶的杀手
  • 漫谈原型模式

    如果对象的创建成本比较大,而同一个类的不同对象之间差别不大(大部分字段都相同),在这种情况下,我们可以利用对已有对象(原型)进行复制(或者叫拷贝)的方式来创建新...

    WindCoder

扫码关注云+社区

领取腾讯云代金券