c++开发必知的单例模式实现总结

前言

最近个人在写一些小的练手的项目,发现单例模式的应用实在是很广泛,很多情况下一个类都需要使用单例模式来实现,因此这里我再度总结一下单例模式的实现,之前已经总结过一次,当时的例子给的是muduo的单例模式实现,这次再给出几种其他的实现,同时进行一下比较。

饿汉模式

饿汉模式就是在还未使用变量的时候,已经对该变量进行赋值,有点类似很饥饿的感觉,在main函数开始执行前就已经初始化好了,因此是线程安全的。

不考虑析构函数的饿汉模式实现
#include 

using namespace std;

class singleton
{
protected:
  singleton() {};
private:
  singleton(const singleton&) {};
  singleton& operator=(const singleton&) {};
  static singleton* m_instance;
public:
  static singleton* GetInstance();
  ~singleton()
  {
    printf("Singleton destruction\n");
  }
};

singleton* singleton::GetInstance()
{
  return m_instance;
}

singleton* singleton::m_instance = new singleton;

int main()
{
  singleton *ct = singleton::GetInstance();
  return 0;
}
饿汉模式的优点
  1. 线程安全
  2. 简单易懂易实现
饿汉模式的缺点
  1. 不适合对性能有要求的场景,因为有些场景下可能不会用到这个变量,这样就无需加载
  2. 在main函数之前就已经初始化完成,基本上没办法给类传入参数

懒汉模式

这个从名字上更容易理解,懒汉就是不到万不得已绝不行动,对于单例模式来说就是默认情况下变量不初始化为nullptr,而在GetInstance方法被调用的时候才会判断instance是否已经被初始化,然后再决定是否要初始化,不过这个行为导致的一个重要问题就是线程不安全。

不考虑析构函数的懒汉模式实现
#include 

using namespace std;

class singleton
{
protected:
  singleton() {};
private:
  singleton(const singleton&) {};
  singleton& operator=(const singleton&) {};
  static singleton* m_instance;
public:
  static singleton* GetInstance();
  ~singleton()
  {
    printf("Singleton destruction\n");
  }
};

singleton* singleton::GetInstance()
{
  if (m_instance == NULL)
  {
    m_instance = new singleton;
  }
  return m_instance;
}

singleton* singleton::m_instance = NULL;

int main()
{
  singleton *ct = singleton::GetInstance();
  return 0;
}
解决懒汉模式线程不安全的几种方法
使用局部静态变量

局部静态变量的初始化是线程安全的,这一点由编译器保证.(http://gcc.gnu.org/ml/gcc-patches/2004-09/msg00265.html). 这是一个 GCC 的 patch,专门解决这个问题)。会在程序退出的时候自动销毁。不过需要注意的是,这个方法适合 C++11,C++11保证静态局部变量的初始化是线程安全的。如果是 C++98 就不能用这个方法。

class S
{
    public:
        static S& getInstance()
        {
            static S instance;
            return instance;
        }
    private:
        S() {}
        S(S const&) = delete;              // Don't Implement.
        void operator=(S const&) = delete; // Don't implement
 };
加锁

这个办法应该是最简单最直接的了,代码实现如下:

// singleton.h
class Singleton {
  public:
    static Singleton *GetInstance() {
      std::lock_guard lck(mutex_);
      if (p == NULL) {
        p = new Singleton;
      }
      return p;
    }
  private:
    std::mutex mutex_;
    static Singleon *p;
    Singleton() {}
    Singleton(const Singleton &) = delete;
    Singleton& operator= (const Singleton &) = delete;
};

// singleton.cpp
Singleton *Singleton::p = NULL;

这个方法的缺点是每次调用GetInstance都会加锁,在多线程的情况下可能会轻微增加程序的负担。

pthread_once

这个是我在以前推荐的博客里面写的,陈硕推荐的单例模式实现,是一个非常好的实现方式,不过仅限于在linux系统下

// singleton.h
class Singleton {
    public:
        static Singleton *GetInstance() {
            pthread_once(&ponce_, &Singleton::init);
            return value_;
        }
    private:
        Singleton() {}
        Singleton(const Singleton &) = delete;
        Singleton& operator= (const Singleton &) = delete;
        static void init() {
            value_ = new T();
        }
        static pthread_once_t ponce_;
        static Singleton *value_;
};
// singleton.cpp
pthread_once_t SIngleton::ponce_ = PTHREAD_ONCE_INIT;
Singleton* Singleton::value_ = NULL;
Double Check Locking(DCL)

double check locking. 只能用内存屏障,其他做法都是有问题的。普通的 double check 之所以错,是因为乱序执行和多处理器下,不同 CPU 中间 cache 刷往内存并对其他 CPU 可见的顺序无法保障(cache coherency problem)。比如

Singleton *p = new Singleton;

这个语句的实际执行过程有三步:

  1. 分配内存
  2. 构造对象
  3. 赋值给p

由于乱序执行,因此2和3的执行顺序实际上是不一定的。因此,如果在某些情况下,3先于2执行,那么就会出现p实际上指向一个无效的对象,但是由于p已经不再是空指针,所以在DCL的第一步判断p是否为空指针时,顺利通过,然后p被返回,然而此时的p指向的内存是位被构造的。
可能有同学认为可以增加一个临时变量temp_p,当temp_p构造完成之后再赋值给p,但是对于现代的编译器这样做是没有意义的,因为现代编译器会认为temp_p是无效的,可能会被优化掉,因此就回到了上一个问题,因此DCL不是线程安全的。

自动调用析构函数

在前面说的懒汉模式不考虑析构函数和饿汉模式不考虑析构函数中,代码中我们虽然都写了析构函数,但是如果我们运行的话会发现,其实析构函数并不会被调用,这是为什么呢,其实答案很简单,因此我们的对象是new出来的,然而我们并没有显式的调用delete,因此析构函数自然不会被调用,那么我们是需要手动调用析构函数吗,其实并非如此,我们希望一种可以自动调用析构函数的方式来实现,其实也很简单,就是之前说的局部静态变量,实现如下,其实和之前一样:

#include 

using namespace std;

class singleton
{
protected:
  singleton() {};
private:
  singleton(const singleton&) {};
  singleton& operator=(const singleton&) {};
public:
  static singleton* GetInstance();
  ~singleton()
  {
    printf("Singleton destruction\n");
  }
};

singleton* singleton::GetInstance()
{
  static singleton m_instance;
  return &m_instance;
}

int main()
{
  singleton *ct = singleton::GetInstance();
  return 0;
}

其实写到这里基本就差不多了,不过这个方法的缺点就是只有在c++11标准下才能保证其正确性,不过从目前来看,c++11的普及性已经很好了,所以基本上不怎么需要担心这个问题

总结

其实说到这里,单例模式就讲的差不多了,陈硕推荐的pthread_once方法和c++11下静态局部变量的方法都是很不错的,值得学习。

本文首发于我的公众号:码农手札,主要介绍linux下c++开发的知识包括网络编程的知识同时也会介绍一些有趣的算法题,欢迎大家关注,利用碎片时间学习一些编程知识,冰冻三尺非一日之寒,让我们一起加油!

你可能感兴趣的:(c++开发必知的单例模式实现总结)