C++单例模式

局部静态变量方式

2. //通过静态成员变量实现单例
3. //懒汉式
4. class Single2
5. {
6. private:
7.     Single2()
8.     {
9.     }
10.     Single2(const Single2 &) = delete;
11.     Single2 &operator=(const Single2 &) = delete;
12. public:
13.     static Single2 &GetInst()
14.     {
15.         static Single2 single;
16.         return single;
17.     }
18. };

复制代码

一个经典的懒汉式单例模式实现，通过静态成员变量来确保 Single2 类只有一个实例。这个实现是准确的，但有几点必要留意：

•         线程安全性：在C++11及更高版本中，局部静态变量（如 GetInst 方法中的 static Single2 single）的初始化是线程安全的。因此，这个实现是线程安全的，不会在多线程环境中引发标题。
  
•         构造函数和赋值运算符的删除：你通过 delete 删除了拷贝构造函数和赋值运算符，这可以防止在外部创建类的拷贝或通过赋值创建多个实例，这是单例模式的准确做法。
  
•         懒汉式单例的使用：懒汉式单例在初次调用 GetInst 时才会创建实例，如许可以制止步伐启动时不须要的内存斲丧。
  

在C++11以下的版本中，使用你提供的懒汉式单例实现大概会遇到线程安全标题。详细来说，标题出现在静态局部变量 single 的初始化上。
线程安全标题

在C++11之前，局部静态变量的初始化不是线程安全的。假如多个线程同时初次调用 GetInst 方法，有大概会发生竞态条件（race condition），导致创建出多个 Single2 实例，粉碎了单例模式的初志。
办理方法

假如必要在C++11以下的版本中确保线程安全，可以思量以下几种方法：

•         双重查抄锁定（Double-Checked Locking）：
  

2. class Single2
3. {
4. private:
5.     static Single2* instance;
6.     static std::mutex mtx;
7.     Single2() {}
8.     Single2(const Single2 &) = delete;
9.     Single2 &operator=(const Single2 &) = delete;
11. public:
12.     static Single2* GetInst()
13.     {
14.         if (instance == nullptr) // 第一次检查
15.         {
16.             std::lock_guard<std::mutex> lock(mtx); // 加锁
17.             if (instance == nullptr) // 第二次检查
18.             {
19.                 instance = new Single2();
20.             }
21.         }
22.         return instance;
23.     }
24. };
26. Single2* Single2::instance = nullptr;
27. std::mutex Single2::mtx;

复制代码

•         静态成员变量初始化（线程不安全版本）：
  

假如你确定单例只会在单线程环境下使用，可以使用以下更简朴的方式：

2. class Single2
3. {
4. private:
5.     static Single2* instance;
6.     Single2() {}
7.     Single2(const Single2 &) = delete;
8.     Single2 &operator=(const Single2 &) = delete;
10. public:
11.     static Single2* GetInst()
12.     {
13.         if (instance == nullptr)
14.         {
15.             instance = new Single2();
16.         }
17.         return instance;
18.     }
19. };
21. Single2* Single2::instance = nullptr;

复制代码

这种实现不实用于多线程环境。

C++11 引入了一些新的特性和改进，此中之一就是包管了局部静态变量的线程安全性。这意味着在 C++11 及更高版本中，局部静态变量的初始化是由编译器主动处置处罚的，而且包管了这种初始化过程在多线程环境下是安全的。
C++11 之前的标题

在 C++11 之前，当多个线程同时初次访问一个局部静态变量时，大概会出现竞态条件（Race Condition），导致多个线程同时进入变量的初始化过程。由于这个初始化过程没有得到线程的同步掩护，大概会导致初始化多次，进而粉碎单例模式的唯一性要求。
C++11 的改进

C++11 标准引入了以下包管：

•         局部静态变量的初始化是线程安全的：C++11 规定，假如多个线程试图同时初始化同一个局部静态变量，只有一个线程会乐成初始化它，而其他线程会被壅闭，直到初始化完成。这就确保了静态局部变量在多线程环境下也只会被初始化一次。
  
•         懒汉式单例的线程安全性：由于局部静态变量的初始化已经是线程安全的，在 C++11 及更高版本中，可以安全地使用局部静态变量来实现懒汉式单例模式，无需额外的锁机制来防止竞态条件。
  

C++11 线程安全的实现机制

在底层，C++11 通过引入新的机制，确保了局部静态变量初始化的线程安全。这些机制包罗：

•         线程同步机制：C++11 在初始化局部静态变量时，使用了编译器提供的同步机制（如锁、屏蔽等）来确保在多线程环境下，只有一个线程可以实行初始化代码。
  
•         按需初始化：C++11 确保局部静态变量在初次使用时才会被初始化，这种方式不但节省资源，还包管了多线程环境中的唯一性。