正文

c++单例模式总结与剖析(代码片段)

一杯清酒邀明月  一杯清酒邀明月  2022-12-01  318

关键词：

C++ 单例模式总结与剖析

单例可能是最常用的简单的一种设计模式，实现方法多样，根据不同的需求有不同的写法; 同时单例也有其局限性，因此有很多人是反对使用单例的。本文对C++ 单例的常见写法进行了一个总结, 包括懒汉式、线程安全、单例模板等；按照从简单到复杂，最终回归简单的的方式循序渐进地介绍，并且对各种实现方法的局限进行了简单的阐述，大量用到了C++ 11的特性如智能指针, magic static，线程锁; 从头到尾理解下来，对于学习和巩固C++语言特性还是很有帮助的。本文的全部代码在 g++ 5.4.0 编译器下编译运行通过，可以在我的github 仓库中找到。

一、什么是单例

单例 Singleton 是设计模式的一种，其特点是只提供唯一一个类的实例,具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例;
具体运用场景如：

设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动;
数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取;

二、C++单例的实现

2.1 基础要点

全局只有一个实例：static 特性，同时禁止用户自己声明并定义实例（把构造函数设为 private）
线程安全
禁止赋值和拷贝
用户通过接口获取实例：使用 static 类成员函数

2.2 C++ 实现单例的几种方式

2.2.1 有缺陷的懒汉式

懒汉式(Lazy-Initialization)的方法是直到使用时才实例化对象，也就说直到调用get_instance() 方法的时候才 new 一个单例的对象，如果不被调用就不会占用内存。

 1 #include <iostream>
 2 // version1:
 3 // with problems below:
 4 // 1. thread is not safe
 5 // 2. memory leak
 6 
 7 class Singleton
 8 private:
 9     Singleton()
10         std::cout<<"constructor called!"<<std::endl;
11     
12     Singleton(Singleton&)=delete;
13     Singleton& operator=(const Singleton&)=delete;
14     static Singleton* m_instance_ptr;
15 public:
16     ~Singleton()
17         std::cout<<"destructor called!"<<std::endl;
18     
19     static Singleton* get_instance()
20         if(m_instance_ptr==nullptr)
21               m_instance_ptr = new Singleton;
22         
23         return m_instance_ptr;
24     
25     void use() const  std::cout << "in use" << std::endl; 
26 ;
27 
28 Singleton* Singleton::m_instance_ptr = nullptr;
29 
30 int main()
31     Singleton* instance = Singleton::get_instance();
32     Singleton* instance_2 = Singleton::get_instance();
33     return 0;
34

运行的结果是

constructor called!

可以看到，获取了两次类的实例，却只有一次类的构造函数被调用，表明只生成了唯一实例，这是个最基础版本的单例实现，他有哪些问题呢？

线程安全的问题,当多线程获取单例时有可能引发竞态条件：第一个线程在if中判断 m_instance_ptr是空的，于是开始实例化单例;同时第2个线程也尝试获取单例，这个时候判断m_instance_ptr还是空的，于是也开始实例化单例;这样就会实例化出两个对象,这就是线程安全问题的由来; 解决办法:加锁
内存泄漏. 注意到类中只负责new出对象，却没有负责delete对象，因此只有构造函数被调用，析构函数却没有被调用;因此会导致内存泄漏。解决办法：使用共享指针;

因此，这里提供一个改进的，线程安全的、使用智能指针的实现;

2.2.2 线程安全、内存安全的懒汉式单例（智能指针，锁）

 1 #include <iostream>
 2 #include <memory> // shared_ptr
 3 #include <mutex>  // mutex
 4 
 5 // version 2:
 6 // with problems below fixed:
 7 // 1. thread is safe now
 8 // 2. memory doesn\'t leak
 9 
10 class Singleton
11 public:
12     typedef std::shared_ptr<Singleton> Ptr;
13     ~Singleton()
14         std::cout<<"destructor called!"<<std::endl;
15     
16     Singleton(Singleton&)=delete;
17     Singleton& operator=(const Singleton&)=delete;
18     static Ptr get_instance()
19 
20         // "double checked lock"
21         if(m_instance_ptr==nullptr)
22             std::lock_guard<std::mutex> lk(m_mutex);
23             if(m_instance_ptr == nullptr)
24               m_instance_ptr = std::shared_ptr<Singleton>(new Singleton);
25             
26         
27         return m_instance_ptr;
28     
29 
30 
31 private:
32     Singleton()
33         std::cout<<"constructor called!"<<std::endl;
34     
35     static Ptr m_instance_ptr;
36     static std::mutex m_mutex;
37 ;
38 
39 // initialization static variables out of class
40 Singleton::Ptr Singleton::m_instance_ptr = nullptr;
41 std::mutex Singleton::m_mutex;
42 
43 int main()
44     Singleton::Ptr instance = Singleton::get_instance();
45     Singleton::Ptr instance2 = Singleton::get_instance();
46     return 0;
47

运行结果如下，发现确实只构造了一次实例，并且发生了析构。

1 constructor called!
2 destructor called!

shared_ptr和mutex都是C++11的标准，以上这种方法的优点是

基于 shared_ptr, 用了C++比较倡导的 RAII思想，用对象管理资源,当 shared_ptr 析构的时候，new 出来的对象也会被 delete掉。以此避免内存泄漏。
加了锁，使用互斥量来达到线程安全。这里使用了两个 if判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，避免每次调用 get_instance的方法都加锁，锁的开销毕竟还是有点大的。

不足之处在于：使用智能指针会要求用户也得使用智能指针，非必要不应该提出这种约束; 使用锁也有开销; 同时代码量也增多了，实现上我们希望越简单越好。

还有更加严重的问题，在某些平台（与编译器和指令集架构有关），双检锁会失效！具体可以看这篇文章，解释了为什么会发生这样的事情。

因此这里还有第三种的基于 Magic Staic的方法达到线程安全

2.2.3 最推荐的懒汉式单例(magic static )——局部静态变量

 1 #include <iostream>
 2 
 3 class Singleton
 4 
 5 public:
 6     ~Singleton()
 7         std::cout<<"destructor called!"<<std::endl;
 8     
 9     Singleton(const Singleton&)=delete;
10     Singleton& operator=(const Singleton&)=delete;
11     static Singleton& get_instance()
12         static Singleton instance;
13         return instance;
14 
15     
16 private:
17     Singleton()
18         std::cout<<"constructor called!"<<std::endl;
19     
20 ;
21 
22 int main(int argc, char *argv[])
23 
24     Singleton& instance_1 = Singleton::get_instance();
25     Singleton& instance_2 = Singleton::get_instance();
26     return 0;
27

运行结果

1 constructor called!
2 destructor called!

这种方法又叫做 Meyers\' SingletonMeyer\'s的单例，是著名的写出《Effective C++》系列书籍的作者 Meyers 提出的。所用到的特性是在C++11标准中的Magic Static特性：

If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.
如果当变量在初始化的时候，并发同时进入声明语句，并发线程将会阻塞等待初始化结束。

这样保证了并发线程在获取静态局部变量的时候一定是初始化过的，所以具有线程安全性。

C++静态变量的生存期是从声明到程序结束，这也是一种懒汉式。

这是最推荐的一种单例实现方式：

通过局部静态变量的特性保证了线程安全 (C++11, GCC > 4.3, VS2015支持该特性);
不需要使用共享指针，代码简洁；
注意在使用的时候需要声明单例的引用 Single& 才能获取对象。

另外网上有人的实现返回指针而不是返回引用

1 static Singleton* get_instance()
2     static Singleton instance;
3     return &instance;
4

这样做并不好，理由主要是无法避免用户使用delete instance导致对象被提前销毁。还是建议大家使用返回引用的方式。

2.2.4 函数返回引用

有人在网上提供了这样一种单例的实现方式；

 1 #include <iostream>
 2 
 3 class A
 4 
 5 public:
 6     A() 
 7         std::cout<<"constructor" <<std::endl;
 8     
 9     ~A()
10         std::cout<<"destructor"<<std::endl;
11     
12 ;
13 
14 
15 A& ret_singleton()
16     static A instance;
17     return instance;
18 
19 
20 int main(int argc, char *argv[])
21 
22     A& instance_1 = ret_singleton();
23     A& instance_2 = ret_singleton();
24     return 0;
25

严格来说，这不属于单例了，因为类A只是个寻常的类，可以被定义出多个实例，但是亮点在于提供了ret_singleton的方法，可以返回一个全局（静态）变量，起到类似单例的效果，这要求用户必须保证想要获取全局变量A ，只通过ret_singleton()的方法。

以上是各种方法实现单例的代码和说明，解释了各种技术实现的初衷和原因。这里会比较推荐 C++11 标准下的 2.2.3 的方式，即使用static local的方法，简单的理由来说是因为其足够简单却满足所有需求和顾虑。

在某些情况下，我们系统中可能有多个单例，如果都按照这种方式的话，实际上是一种重复，有没有什么方法可以只实现一次单例而能够复用其代码从而实现多个单例呢？很自然的我们会考虑使用模板技术或者继承的方法，
在我的博客中有介绍过如何使用单例的模板。

2.3 单例的模板

2.3.1 CRTP 奇异递归模板模式实现

代码示例如下：

 1 // brief: a singleton base class offering an easy way to create singleton
 2 #include <iostream>
 3 
 4 template<typename T>
 5 class Singleton
 6 public:
 7     static T& get_instance()
 8         static T instance;
 9         return instance;
10     
11     virtual ~Singleton()
12         std::cout<<"destructor called!"<<std::endl;
13     
14     Singleton(const Singleton&)=delete;
15     Singleton& operator =(const Singleton&)=delete;
16 protected:
17     Singleton()
18         std::cout<<"constructor called!"<<std::endl;
19     
20 
21 ;
22 /********************************************/
23 // Example:
24 // 1.friend class declaration is requiered!
25 // 2.constructor should be private
26 
27 
28 class DerivedSingle:public Singleton<DerivedSingle>
29    // !!!! attention!!!
30    // needs to be friend in order to
31    // access the private constructor/destructor
32    friend class Singleton<DerivedSingle>;
33 public:
34    DerivedSingle(const DerivedSingle&)=delete;
35    DerivedSingle& operator =(const DerivedSingle&)= delete;
36 private:
37    DerivedSingle()=default;
38 ;
39 
40 int main(int argc, char* argv[])
41     DerivedSingle& instance1 = DerivedSingle::get_instance();
42     DerivedSingle& instance2 = DerivedSingle::get_instance();
43     return 0;
44

以上实现一个单例的模板基类，使用方法如例子所示意，子类需要将自己作为模板参数T 传递给 Singleton<T> 模板; 同时需要将基类声明为友元，这样才能调用子类的私有构造函数。

基类模板的实现要点是：

构造函数需要是 protected，这样子类才能继承；
使用了奇异递归模板模式CRTP(Curiously recurring template pattern)
get instance 方法和 2.2.3 的static local方法一个原理。
在这里基类的析构函数可以不需要 virtual ，因为子类在应用中只会用 Derived 类型，保证了析构时和构造时的类型一致

2.3.2 不需要在子类声明友元的实现方法

在 stackoverflow上，有大神给出了不需要在子类中声明友元的方法，在这里一并放出;精髓在于使用一个代理类 token，子类构造函数需要传递token类才能构造，但是把 token保护其起来，然后子类的构造函数就可以是公有的了，这个子类只有 Derived(token)的这样的构造函数，这样用户就无法自己定义一个类的实例了，起到控制其唯一性的作用。代码如下。

 1 // brief: a singleton base class offering an easy way to create singleton
 2 #include <iostream>
 3 
 4 template<typename T>
 5 class Singleton
 6 public:
 7     static T& get_instance() noexcept(std::is_nothrow_constructible<T>::value)
 8         static T instancetoken();
 9         return instance;
10     
11     virtual ~Singleton() =default;
12     Singleton(const Singleton&)=delete;
13     Singleton& operator =(const Singleton&)=delete;
14 protected:
15     struct token; // helper class
16     Singleton() noexcept=default;
17 ;
18 
19 
20 /********************************************/
21 // Example:
22 // constructor should be public because protected `token` control the access
23 
24 
25 class DerivedSingle:public Singleton<DerivedSingle>
26 public:
27    DerivedSingle(token)
28        std::cout<<"destructor called!"<<std::endl;
29    
30 
31    ~DerivedSingle()
32        std::cout<<"constructor called!"<<std::endl;
33    
34    DerivedSingle(const DerivedSingle&)=delete;
35    DerivedSingle& operator =(const DerivedSingle&)= delete;
36 ;
37 
38 int main(int argc, char* argv[])
39     DerivedSingle& instance1 = DerivedSingle::get_instance();
40     DerivedSingle& instance2 = DerivedSingle::get_instance();
41     return 0;
42

2.3.3 函数模板返回引用

在 2.2.4 中提供了一种类型的全局变量的方法，可以把一个一般的类，通过这种方式提供一个类似单例的
全局性效果（但是不能阻止用户自己声明定义这样的类的对象）;在这里我们把这个方法变成一个 template 模板函数，然后就可以得到任何一个类的全局变量。

 1 #include <iostream>
 2 
 3 class A
 4 
 5 public:
 6     A() 
 7         std::cout<<"constructor" <<std::endl;
 8     
 9     ~A()
10         std::cout<<"destructor"<<std::endl;
11     
12 ;
13 
14 template<typename T>
15 T& get_global()
16     static T instance;
17     return instance;
18 
19 
20 int main(int argc, char *argv[])
21 
22     A& instance_1 = get_global<A>();
23     A& instance_2 = get_global<A>();
24     return 0;
25

可以看到这种方式确实非常简洁，同时类仍然具有一般类的特点而不受限制，当然也因此失去了单例那么强的约束（禁止赋值、构造和拷贝构造）。
这里把函数命名为 get_global() 是为了强调，这里可以通过这种方式获取得到单例最重要的全局变量特性；但是并不是单例的模式。

三、何时应该使用或者不使用单例

根据stackoverflow上的一个高票答案 singleton-how-should-it-be-used：

You need to have one and only one object of a type in system
你需要系统中只有唯一一个实例存在的类的全局变量的时候才使用单例。

如果使用单例，应该用什么样子的

How to create the best singleton:

The smaller, the better. I am a minimalist

Make sure it is thread safe

Make sure it is never null

Make sure it is created only once

Lazy or system initialization? Up to your requirements

Sometimes the OS or the JVM creates singletons for you (e.g. in Java every class definition is a singleton)

Provide a destructor or somehow figure out how to dispose resources

Use little memory
越小越好，越简单越好，线程安全，内存不泄露

反对单例的理由

当然程序员是分流派的，有些是反对单例的，有些人是反对设计模式的，有些人甚至连面向对象都反对

单例模式的懒汉模式与饿汉模式之间的对比c++(代码片段)

单例模式，是GOF23种设计模式中的一种，有2种方法可以实现单例模式，分为懒汉式、饿汉式，它们的区别如下：对比懒汉式单例饿汉式单例创建时间需要时才创建，在程序运行之后调用getInstance()创建... 查看详情

c++单例模式(代码片段)

/单例模式：C1getInstance和m_instance必是static变量，C2m_instance必被明确的初始化。C3构造函数与拷贝构造函数，析构函数全是private，可以只声明。C4需要有明确的Destory函数C5需要在线程安全。///Singleton.h#include<iostream>#include<strin... 查看详情

单例模式的c++实现（懒汉模式和饿汉模式的详细讲解和实现）(代码片段)

文章目录前言一、单例模式的概念1.2单例模式的分类1.2懒汉和饿汉的利弊二、代码实现1.饿汉模式2.懒汉模式总结前言提示：单例模式的出现。由于在某些场景中你最多而且必须有一个对象存在的情况，比如，监控摄... 查看详情

c++单例模式(代码片段)

单例模式：单例大约有两种实现方法：懒汉与饿汉。懒汉：故名思义，不到万不得已就不会去实例化类，也就是说在第一次用到类实例的时候才会去实例化，饿汉：饿了肯定要饥不择食。所以在单例类... 查看详情

c++单例模式(代码片段)

什么是单例模式？　　一种创建型的设计模式，该模式的主要目的就是确保某个类有且仅有一个实例存在。单例模式有三个关键点：　　1、单例类只能有一个实例。　　　　为此，单例类只能提供私有的构造函数，即保证... 查看详情

c++单例模式(代码片段)

1.什么是单例模式因为在设计或开发中，肯定会有这么一种情况，一个类只能有一个对象被创建，如果有多个对象的话，可能会导致状态的混乱和不一致。这种情况下，单例模式是最恰当的解决办法。2.单例模式实现Singleton.cpp#inc... 查看详情

c++单例模式的实现（懒汉式饿汉式）(代码片段)

单例模式-Singleton名词解释动机要点饿汉式实现方式运行结果懒汉式常规实现线程安全版实现精简实现参考资料名词解释数学与逻辑学中，singleton定义为：有且仅有一个元素的集合。单例模式最初的定义出现在《设计模式... 查看详情

c++设计模式：单例模式(代码片段)

1.设计思想:　　单例模式，顾名思义，即一个类只有一个实例对象。C++一般的方法是将构造函数、拷贝构造函数以及赋值操作符函数声明为private级别，从而阻止用户实例化一个类。那么，如何才能获得该类的对象呢？这时，需... 查看详情

c++单例模式（singleton）(代码片段)

文章目录1.static实现2.计数器实现1.static实现单例模式是设计模式中最简单的设计模式，也是做容易实现的模式。所谓单例模式就是让某个类只能产生一个对象。那么在C++语言中该如何设计呢？用static关键字可以实现... 查看详情

23种设计模式归纳总结——创建型(代码片段)

目录1.单例模式2.工厂模式3.Builder模式4.原型模式1.单例模式1.饿汉式:在类加载时进行实例的创建与初始化publicclassIdGeneratorprivateAtomicLongid=newAtomicLong(0);privatestaticfinalIdGeneratorinstance=newIdGenerator();privateIdGenerator( 查看详情

设计模式之单例模式总结(代码片段)

常见的实现单例的方法大致分为五种*饿汉模式*懒汉模式*双重检查锁*内部类*枚举1.饿汉模式publicclassSingle1privatestaticSingle1single=newSingle1();privateSingle1()publicstaticSingle1getInstance()returnsingle;2.懒汉模式#2.1 *懒汉模式 *线程不安全【... 查看详情

日期类时间类，日期时间类，单例模式，装箱与拆箱，数字类随机数，bigdecimal总结(代码片段)

1.日期类，时间类，日期时间类初步日期使用方法及格式转换方法（旧方法）:格式：//MonJul3011:26:05CST2018 年月日时分秒 CST代表北京时间获取当前毫秒Datedate=newDate(... 查看详情

设计模式之单例模式(代码片段)

目录概念原文概念翻译特点原理优点与缺点优点缺点应用场景项目或框架应用代码实现饿汉式优缺点优点缺点代码实现懒汉式常规版优缺点优点缺点代码实现方法全局锁定优缺点优点缺点代码实现单重检查优缺点优点缺点代码实... 查看详情

c++之特殊类的设计(单例模式)(代码片段)

特殊类的设计(单例模式)文章目录特殊类的设计(单例模式)请设计一个类，只能在堆上创建对象方法一方法二请设计一个类，只能在栈上创建对象方法一方法二请设计一个类，不能被拷贝C++98C++11请设计一个... 查看详情

23种设计模式归纳总结——创建型(代码片段)

目录1.单例模式2.工厂模式3.Builder模式4.原型模式主要解决“对象的创建”问题，将创建和使用代码解耦1.单例模式1.饿汉式:在类加载时进行实例的创建与初始化publicclassIdGeneratorprivateAtomicLongid=newAtomicLong(0);privatestaticfinalIdGen... 查看详情

23种设计模式归纳总结——创建型(代码片段)

c++：静态成员及单例模式(代码片段)

单例模式:一个类只能创建出一个对象单例模式实现的步骤:将无参构造私有化将拷贝构造私有化将静态的成员指针变量私有化,提供获得唯一对象的地址的静态接口定义一个静态的成员指针变量指向new出来的一个唯一对象#define_CRT_... 查看详情

设计模式-单例模式学习总结(代码片段)

一、单例模式的使用场景　　1.windows下的任务管理器以及回收站，整个系统中维护着一个实例　　2.网站的计数器，用来达到数据的同步　　3.web应用配置对象的读取，使得配置文件成为共享资源　　4.数据库连接池对象，主要是... 查看详情

正文

c++单例模式总结与剖析(代码片段)

C++ 单例模式总结与剖析

一、什么是单例

二、C++单例的实现

2.1 基础要点

2.2 C++ 实现单例的几种方式

2.2.1 有缺陷的懒汉式

2.2.2 线程安全、内存安全的懒汉式单例 （智能指针，锁）

2.2.3 最推荐的懒汉式单例(magic static )——局部静态变量

2.2.4 函数返回引用

2.3 单例的模板

2.3.1 CRTP 奇异递归模板模式实现

2.3.2 不需要在子类声明友元的实现方法

2.3.3 函数模板返回引用

三、何时应该使用或者不使用单例

反对单例的理由

单例模式的懒汉模式与饿汉模式之间的对比c++(代码片段)

c++单例模式(代码片段)

单例模式的c++实现（懒汉模式和饿汉模式的详细讲解和实现）(代码片段)

c++单例模式(代码片段)

c++单例模式(代码片段)

c++单例模式(代码片段)

c++单例模式的实现（懒汉式饿汉式）(代码片段)

c++设计模式：单例模式(代码片段)

c++单例模式（singleton）(代码片段)

23种设计模式归纳总结——创建型(代码片段)

设计模式之单例模式总结(代码片段)

日期类时间类，日期时间类，单例模式，装箱与拆箱，数字类随机数，bigdecimal总结(代码片段)

设计模式之单例模式(代码片段)

c++之特殊类的设计(单例模式)(代码片段)

23种设计模式归纳总结——创建型(代码片段)

23种设计模式归纳总结——创建型(代码片段)

c++：静态成员及单例模式(代码片段)

设计模式-单例模式学习总结(代码片段)

2.2.2 线程安全、内存安全的懒汉式单例（智能指针，锁）