一、线程安全

1.1 什么是线程安全？

在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

1.2 如何保证线程安全？

  1. 给共享的资源加把锁，保证每个资源变量每时每刻至多被一个线程占用。
  2. 让线程也拥有资源，不用去共享进程中的资源。如： 使用threadlocal可以为每个线程的维护一个私有的本地变量。

二、单例模式

单例模式指在整个系统生命周期里，保证一个类只能产生一个实例，确保该类的唯一性。

2.1 单例模式分类

单例模式可以分为懒汉式和饿汉式，两者之间的区别在于创建实例的时间不同：

  • 懒汉式：指系统运行中，实例并不存在，只有当需要使用该实例时，才会去创建并使用实例。（这种方式要考虑线程安全）

  • 饿汉式：指系统一运行，就初始化创建实例，当需要时，直接调用即可。（本身就线程安全，没有多线程的问题）

    2.2 单例类特点

  • 构造函数和析构函数为private类型，目的禁止外部构造和析构

  • 拷贝构造和赋值构造函数为private类型，目的是禁止外部拷贝和赋值，确保实例的唯一性
  • 类里有个获取实例的静态函数，可以全局访问

2.3 普通懒汉式单例 （ 线程不安全 ）

  1. ///////////////////  普通懒汉式实现 -- 线程不安全 //////////////////
  2. #include <iostream> // std::cout
  3. #include <mutex>    // std::mutex
  4. #include <pthread.h> // pthread_create
  6. class SingleInstance
  7. {
  9. public:
  10.     // 获取单例对象
  11.     static SingleInstance *GetInstance();
  13.     // 释放单例，进程退出时调用
  14.     static void deleteInstance();
  16.     // 打印单例地址
  17.     void Print();
  19. private:
  20.     // 将其构造和析构成为私有的, 禁止外部构造和析构
  21.     SingleInstance();
  22.     ~SingleInstance();
  24.     // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
  25.     SingleInstance(const SingleInstance &signal);
  26.     const SingleInstance &operator=(const SingleInstance &signal);
  28. private:
  29.     // 唯一单例对象指针
  30.     static SingleInstance *m_SingleInstance;
  31. };
  33. //初始化静态成员变量
  34. SingleInstance *SingleInstance::m_SingleInstance = NULL;
  36. SingleInstance* SingleInstance::GetInstance()
  37. {
  39.     if (m_SingleInstance == NULL)
  40.     {
  41.         m_SingleInstance = new (std::nothrow) SingleInstance;  // 没有加锁是线程不安全的，当线程并发时会创建多个实例
  42.     }
  44.     return m_SingleInstance;
  45. }
  47. void SingleInstance::deleteInstance()
  48. {
  49.     if (m_SingleInstance)
  50.     {
  51.         delete m_SingleInstance;
  52.         m_SingleInstance = NULL;
  53.     }
  54. }
  56. void SingleInstance::Print()
  57. {
  58.     std::cout << "我的实例内存地址是:" << this << std::endl;
  59. }
  61. SingleInstance::SingleInstance()
  62. {
  63.     std::cout << "构造函数" << std::endl;
  64. }
  66. SingleInstance::~SingleInstance()
  67. {
  68.     std::cout << "析构函数" << std::endl;
  69. }
  70. ///////////////////  普通懒汉式实现 -- 线程不安全  //////////////////
  72. // 线程函数
  73. void *PrintHello(void *threadid)
  74. {
  75.     // 主线程与子线程分离，两者相互不干涉，子线程结束同时子线程的资源自动回收
  76.     pthread_detach(pthread_self());
  78.     // 对传入的参数进行强制类型转换，由无类型指针变为整形数指针，然后再读取
  79.     int tid = *((int *)threadid);
  81.     std::cout << "Hi, 我是线程 ID:[" << tid << "]" << std::endl;
  83.     // 打印实例地址
  84.     SingleInstance::GetInstance()->Print();
  86.     pthread_exit(NULL);
  87. }
  89. #define NUM_THREADS 5 // 线程个数
  91. int main(void)
  92. {
  93.     pthread_t threads[NUM_THREADS] = {0};
  94.     int indexes[NUM_THREADS] = {0}; // 用数组来保存i的值
  96.     int ret = 0;
  97.     int i = 0;
  99.     std::cout << "main() : 开始 ... " << std::endl;
  101.     for (i = 0; i < NUM_THREADS; i++)
  102.     {
  103.         std::cout << "main() : 创建线程:[" << i << "]" << std::endl;
  105.         indexes[i] = i; //先保存i的值
  107.         // 传入的时候必须强制转换为void* 类型，即无类型指针
  108.         ret = pthread_create(&threads[i], NULL, PrintHello, (void *)&(indexes[i]));
  109.         if (ret)
  110.         {
  111.             std::cout << "Error:无法创建线程," << ret << std::endl;
  112.             exit(-1);
  113.         }
  114.     }
  116.     // 手动释放单实例的资源
  117.     SingleInstance::deleteInstance();
  118.     std::cout << "main() : 结束! " << std::endl;
  120.     return 0;
  121. }

普通懒汉式单例运行结果：
从运行结果可知，单例构造函数创建了两个，内存地址分别为0x7f3c980008c0和0x7f3c900008c0，所以普通懒汉式单例只适合单进程不适合多线程，因为是线程不安全的。
单例模式 - 图1

2.4 加锁的懒汉式单例 （ 线程安全 ）

  1. ///////////////////  加锁的懒汉式实现  //////////////////
  2. class SingleInstance
  3. {
  5. public:
  6.     // 获取单实例对象
  7.     static SingleInstance *&GetInstance();
  9.     //释放单实例，进程退出时调用
  10.     static void deleteInstance();
  12.     // 打印实例地址
  13.     void Print();
  15. private:
  16.     // 将其构造和析构成为私有的, 禁止外部构造和析构
  17.     SingleInstance();
  18.     ~SingleInstance();
  20.     // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
  21.     SingleInstance(const SingleInstance &signal);
  22.     const SingleInstance &operator=(const SingleInstance &signal);
  24. private:
  25.     // 唯一单实例对象指针
  26.     static SingleInstance *m_SingleInstance;
  27.     static std::mutex m_Mutex;
  28. };
  30. //初始化静态成员变量
  31. SingleInstance *SingleInstance::m_SingleInstance = NULL;
  32. std::mutex SingleInstance::m_Mutex;
  34. SingleInstance *&SingleInstance::GetInstance()
  35. {
  37.     //  这里使用了两个 if判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，
  38.     //  避免每次调用 GetInstance的方法都加锁，锁的开销毕竟还是有点大的。
  39.     if (m_SingleInstance == NULL) 
  40.     {
  41.         std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
  42.         if (m_SingleInstance == NULL)
  43.         {
  44.             m_SingleInstance = new (std::nothrow) SingleInstance;
  45.         }
  46.     }
  48.     return m_SingleInstance;
  49. }
  51. void SingleInstance::deleteInstance()
  52. {
  53.     std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
  54.     if (m_SingleInstance)
  55.     {
  56.         delete m_SingleInstance;
  57.         m_SingleInstance = NULL;
  58.     }
  59. }
  61. void SingleInstance::Print()
  62. {
  63.     std::cout << "我的实例内存地址是:" << this << std::endl;
  64. }
  66. SingleInstance::SingleInstance()
  67. {
  68.     std::cout << "构造函数" << std::endl;
  69. }
  71. SingleInstance::~SingleInstance()
  72. {
  73.     std::cout << "析构函数" << std::endl;
  74. }

加锁的懒汉式单例的运行结果：
从运行结果可知，只创建了一个实例，内存地址是0x7f28b00008c0，所以加了互斥锁的普通懒汉式是线程安全的
单例模式 - 图2

2.5 内部静态变量的懒汉单例（C++11 线程安全）

  1. ///////////////////  内部静态变量的懒汉实现  //////////////////
  2. class Single
  3. {
  5. public:
  6.     // 获取单实例对象
  7.     static Single &GetInstance();
  9.     // 打印实例地址
  10.     void Print();
  12. private:
  13.     // 禁止外部构造
  14.     Single();
  16.     // 禁止外部析构
  17.     ~Single();
  19.     // 禁止外部复制构造
  20.     Single(const Single &signal);
  22.     // 禁止外部赋值操作
  23.     const Single &operator=(const Single &signal);
  24. };
  26. Single &Single::GetInstance()
  27. {
  28.     // 局部静态特性的方式实现单实例
  29.     static Single signal;
  30.     return signal;
  31. }
  33. void Single::Print()
  34. {
  35.     std::cout << "我的实例内存地址是:" << this << std::endl;
  36. }
  38. Single::Single()
  39. {
  40.     std::cout << "构造函数" << std::endl;
  41. }
  43. Single::~Single()
  44. {
  45.     std::cout << "析构函数" << std::endl;
  46. }

内部静态变量的懒汉单例的运行结果：
-std=c++0x编译是使用了C++11的特性，在C++11内部静态变量的方式里是线程安全的，只创建了一次实例，内存地址是0x6016e8，这个方式非常推荐，实现的代码最少！
[root@lincoding singleInstall]#g++ SingleInstance.cpp -o SingleInstance -lpthread -std=c++0x
单例模式 - 图3

2.6 饿汉式单例 （本身就线程安全）

  1. ////////////////////////// 饿汉实现 /////////////////////
  2. class Singleton
  3. {
  4. public:
  5.     // 获取单实例
  6.     static Singleton* GetInstance();
  8.     // 释放单实例，进程退出时调用
  9.     static void deleteInstance();
  11.     // 打印实例地址
  12.     void Print();
  14. private:
  15.     // 将其构造和析构成为私有的, 禁止外部构造和析构
  16.     Singleton();
  17.     ~Singleton();
  19.     // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
  20.     Singleton(const Singleton &signal);
  21.     const Singleton &operator=(const Singleton &signal);
  23. private:
  24.     // 唯一单实例对象指针
  25.     static Singleton *g_pSingleton;
  26. };
  28. // 代码一运行就初始化创建实例 ，本身就线程安全
  29. Singleton* Singleton::g_pSingleton = new (std::nothrow) Singleton;
  31. Singleton* Singleton::GetInstance()
  32. {
  33.     return g_pSingleton;
  34. }
  36. void Singleton::deleteInstance()
  37. {
  38.     if (g_pSingleton)
  39.     {
  40.         delete g_pSingleton;
  41.         g_pSingleton = NULL;
  42.     }
  43. }
  45. void Singleton::Print()
  46. {
  47.     std::cout << "我的实例内存地址是:" << this << std::endl;
  48. }
  50. Singleton::Singleton()
  51. {
  52.     std::cout << "构造函数" << std::endl;
  53. }
  55. Singleton::~Singleton()
  56. {
  57.     std::cout << "析构函数" << std::endl;
  58. }

饿汉式单例的运行结果：
从运行结果可知，饿汉式在程序一开始就构造函数初始化了，所以本身就线程安全的
单例模式 - 图4

三、特点与选择

  • 懒汉式是以时间换空间，适应于访问量较小时；推荐使用内部静态变量的懒汉单例，代码量少
  • 饿汉式是以空间换时间，适应于访问量较大时，或者线程比较多的的情况