单例模式的实现总结

Posted on | In

前言

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

饿汉模式

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

不考虑析构函数的饿汉模式实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>

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是否已经被初始化，然后再决定是否要初始化，不过这个行为导致的一个重要问题就是线程不安全。

不考虑析构函数的懒汉模式实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <iostream>

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 就不能用这个方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
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
 };
加锁

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// singleton.h
class Singleton {
  public:
    static Singleton *GetInstance() {
      std::lock_guard<std::mutex> 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系统下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 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<T> *p = new Singleton<T>;

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

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

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

自动调用析构函数

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>

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++开发的知识包括网络编程的知识同时也会介绍一些有趣的算法题，欢迎大家关注，利用碎片时间学习一些编程知识，冰冻三尺非一日之寒，让我们一起加油！