AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C++单例懒汉式和多线程问题(MUTEX 保护)

2017-04-10 1063
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 单例懒汉式和多线程问题 作为单例模式，是在整个程序运行期间只会建立一份内存空间，为了达到这个目标 1、需要将构造函数设置为私有成员 2、需要一个私有的静态指针指向自身 3、需要一个公有的静态函数将这个上面的静态指针露出来 如下的代码就是一个懒汉式的单例 ...
单例懒汉式和多线程问题


作为单例模式，是在整个程序运行期间只会建立一份内存空间，为了达到这个目标
1、需要将构造函数设置为私有成员
2、需要一个私有的静态指针指向自身
3、需要一个公有的静态函数将这个上面的静态指针露出来

如下的代码就是一个懒汉式的单例

点击(此处)折叠或打开

  1. #include<iostream>
  2. using namespace std;

  4. class single_ins
  5. {
  6. private:
  7.     int a;
  8.     int b;
  9.     single_ins()
  10.     {
  11.         a= 0;
  12.         b= 0;
  13.     }
  14.     static single_ins* myc;
  15. public:
  16.     void setval(const int& a,const int& b)
  17.     {
  18.         this->a = a;
  19.         this->b = b;
  20.     }

  22.     void print()
  23.     {
  24.       cout<<"a:"<<a<<endl;
  25.       cout<<"b:"<<b<<endl;
  26.     }


  29.     static single_ins* setp()
  30.     {
  31.         //?
  32.         if(myc == NULL)
  33.         {
  34.             myc = new single_ins;
  35.         }
  36.         //?
  37.         return myc;
  38.     }

  40.     static void pfree()
  41.     {
  42.         if(myc != NULL)
  43.         {
  44.             delete myc;
  45.             myc = NULL;
  46.         }
  47.     }

  49. };

  51. //? init static value
  52. single_ins* single_ins::myc = NULL;
  53. //nit static value
  54. //single_ins* single_ins::myc = new single_ins;

  56. int main()
  57. {
  58.     single_ins* a = single_ins::setp();
  59.     single_ins* b = single_ins::setp();
  60.     a->setval(10,20);
  61.     b->print();

  63.     cout<<a<<" "<<b<<endl;
  64.     single_ins::pfree();

  66. }
但是上面的代码有明显的问题，就是遇到多线程的情况下，因为多个线程如果同事创建内存，由于彼此之间
并不能及时检查到内存已经分配，会分配多个内存，这个时候我们至少需要一个线程间同步手段来让他们之间
串行的执行，这个时候就涉及到两次检查(double check)
如果没有mutex保护就是下面这个程序：

点击(此处)折叠或打开

  1. #include <iostream>
  2. #include <unistd.h>
  3. using namespace std;


  6. //单列模式
  7. class single_ins
  8. {
  9.         private:
  10.                 int a;
  11.                 int b;
  12.                 single_ins()
  13.                 {
  14.                         cout<<"con begin\n";
  15.                         a= 0;
  16.                         b= 0;
  17.                         sleep(10); //故意拖长构造函数执行时间，造成懒汉式多线程问题
  18.                         cout<<"con end\n";
  19.                 }
  20.                 static single_ins* myc;//单例需要一个静态指针
  21.                 static int cnt;//构造调用次数统计
  22.         public:
  23.                 void setval(const int& a,const int& b)
  24.                 {
  25.                         this->a = a;
  26.                         this->b = b;
  27.                 }

  29.                 void print()
  30.                 {
  31.                         cout<<"a:"<<a<<endl;
  32.                         cout<<"b:"<<b<<endl;
  33.                         cout<<cnt<<endl;
  34.                 }


  37.                 static single_ins* setp() //函数获得指针值赋给静态成员指针变量
  38.                 {
  39.                         //懒汉式
  40.                         if(myc == NULL)
  41.                         {
  42.                                 myc = new single_ins;
  43.                                 cnt++;
  44.                         }
  45.                         //懒汉式
  46.                         return myc;
  47.                 }
  48.                 static void pfree()
  49.                 {
  50.                         if(myc != NULL)
  51.                         {
  52.                                 delete myc;
  53.                                 myc = NULL;
  54.                         }
  55.                 }
  56. };

  58. //懒汉式 init static value
  59. single_ins* single_ins::myc = NULL;
  60. int single_ins::cnt = 0;
  61. //饿汉试 init static value
  62. //single_ins* single_ins::myc = new single_ins;
  63. /*
  64.    懒汉式的问题在于多线程调用的时候会出现问题，很可能同时建立出多个内存空间，
  65.    而不是单列了。
  66.    */
  67. void* main21(void* argc)
  68. {
  69.         single_ins* inp = (single_ins*)argc;

  71.         inp = single_ins::setp();
  72.         inp->setval(10,20);
  73.         inp->print();
  74.         cout<<inp<<"\n";
  75.         return NULL;
  76. }


  79. int main(void)
  80. {
  81.         pthread_t tid;
  82.         single_ins* a[3] = {NULL};
  83.         void* tret[3] = {NULL};
  84.         for(int i = 0 ; i<3; i++)
  85.         {
  86.                 pthread_create(&tid,NULL,main21,(void*)a[i]);
  87.                 //pthread_join(tid, &(tret[i]));
  88.         }
  89.         sleep(50);
  90.         single_ins::pfree();

  92. }
会跑出结果
con begin
con begin
con begin
con end
a:10
b:20
1
0x7fc3880008c0
con end
a:10
b:20
2
0x7fc3800008c0
con end
a:10
b:20
3
0x7fc3840008c0


可以看到
0x7fc3880008c0 0x7fc3800008c0 0x7fc3840008c0
明显是3个不同的内存空间 这就不对了，而且可以看到构造函数
调用了3次
为此我们使用mutex来保护临时

如下:
 static single_ins* setp() //函数获得指针值赋给静态成员指针变量
 39         {
 40             //懒汉式
 41             if(myc == NULL)
 42             {
 43                 pthread_mutex_lock(&counter_mutex); //mutex 保护临界区
 44                 if(myc == NULL) //两次检查
 45                 {
 46                     myc = new single_ins;                                                                                                                           
 47                     cnt++;
 48                 }
 49                 pthread_mutex_unlock(&counter_mutex); //mutex结束
 50             }


这样代码如下：

点击(此处)折叠或打开

  1. #include <iostream>
  2. #include <unistd.h>
  3. using namespace std;

  5. pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;

  7. //单列模式
  8. class single_ins
  9. {
  10.         private:
  11.                 int a;
  12.                 int b;
  13.                 single_ins()
  14.                 {
  15.                         cout<<"con begin\n";
  16.                         a= 0;
  17.                         b= 0;
  18.                         sleep(10); //故意拖长构造函数执行时间，造成懒汉式多线程问题
  19.                         cout<<"con end\n";
  20.                 }
  21.                 static single_ins* myc;//单例需要一个静态指针
  22.                 static int cnt;//构造调用次数统计
  23.         public:
  24.                 void setval(const int& a,const int& b)
  25.                 {
  26.                         this->a = a;
  27.                         this->b = b;
  28.                 }

  30.                 void print()
  31.                 {
  32.                         cout<<"a:"<<a<<endl;
  33.                         cout<<"b:"<<b<<endl;
  34.                         cout<<cnt<<endl;
  35.                 }


  38.                 static single_ins* setp() //函数获得指针值赋给静态成员指针变量
  39.                 {
  40.                         //懒汉式
  41.                         if(myc == NULL)
  42.                         {
  43.                                 pthread_mutex_lock(&counter_mutex); //mutex 保护临界区
  44.                                 if(myc == NULL) //两次检查
  45.                                 {
  46.                                         myc = new single_ins;
  47.                                         cnt++;
  48.                                 }
  49.                                 pthread_mutex_unlock(&counter_mutex); //mutex结束
  50.                         }
  51.                         //懒汉式
  52.                         return myc;
  53.                 }
  54.                 static void pfree()
  55.                 {
  56.                         if(myc != NULL)
  57.                         {
  58.                                 delete myc;
  59.                                 myc = NULL;
  60.                         }
  61.                 }
  62. };

  64. //懒汉式 init static value
  65. single_ins* single_ins::myc = NULL;
  66. int single_ins::cnt = 0;
  67. //饿汉试 init static value
  68. //single_ins* single_ins::myc = new single_ins;
  69. /*
  70.    懒汉式的问题在于多线程调用的时候会出现问题，很可能同时建立出多个内存空间，
  71.    而不是单列了。
  72.    */



  76. void* main21(void* argc)
  77. {
  78.         single_ins* inp = (single_ins*)argc;

  80.         inp = single_ins::setp();
  81.         inp->setval(10,20);
  82.         inp->print();
  83.         cout<<inp<<"\n";
  84.         return NULL;
  85. }


  88. int main(void)
  89. {
  90.         pthread_t tid;
  91.         single_ins* a[3] = {NULL};
  92.         void* tret[3] = {NULL};
  93.         for(int i = 0 ; i<3; i++)
  94.         {
  95.                 pthread_create(&tid,NULL,main21,(void*)a[i]);
  96.                 //pthread_join(tid, &(tret[i]));
  97.         }
  98.         sleep(50);
  99.         single_ins::pfree();

  101. }
跑出的结果如下：

con begin
con end
a:10a:10
b:20
1
0x7f21f40008c0


b:20
1
0x7f21f40008c0
a:10
b:20
1
0x7f21f40008c0


现在就是正常的了。所以懒汉试单例遇到多线程一定要注意，饿汉试没有问题。
当然这是一个小列子而已，线程安全是一个很大的话题，特别需要注意。

作者微信：

               
文章标签：
C++
关键词：
C++线程
C++多线程
单例线程
线程mutex
C++ mutex
重庆八怪
目录
相关文章
最好zzz
|
1月前
|
缓存 安全 C++
C++无锁队列：解锁多线程编程新境界
【10月更文挑战第27天】
最好zzz
41 7
潇洒洒
|
1月前
|
消息中间件 存储 安全
深入探索C++无锁队列：多线程编程的高效利器
【10月更文挑战第19天】
潇洒洒
114 6
石小浪♪
|
2月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念，包括进程和线程的定义、并发的实现方式，以及如何在C++中创建和管理线程，包括使用`std::thread`库、线程的join和detach方法，并通过示例代码展示了如何创建和使用多线程。
石小浪♪
52 1
C++ 多线程之初识多线程
小王老师呀
|
2月前
|
存储 并行计算 安全
C++多线程应用
【10月更文挑战第29天】C++ 中的多线程应用广泛，常见场景包括并行计算、网络编程中的并发服务器和图形用户界面（GUI）应用。通过多线程可以显著提升计算速度和响应能力。示例代码展示了如何使用 `pthread` 库创建和管理线程。注意事项包括数据同步与互斥、线程间通信和线程安全的类设计，以确保程序的正确性和稳定性。
小王老师呀
38 5
石小浪♪
|
2月前
|
存储 前端开发 C++
C++ 多线程之带返回值的线程处理函数
这篇文章介绍了在C++中使用`async`函数、`packaged_task`和`promise`三种方法来创建带返回值的线程处理函数。
石小浪♪
67 6
石小浪♪
|
2月前
|
C++
C++ 多线程之线程管理函数
这篇文章介绍了C++中多线程编程的几个关键函数，包括获取线程ID的`get_id()`，延时函数`sleep_for()`，线程让步函数`yield()`，以及阻塞线程直到指定时间的`sleep_until()`。
石小浪♪
28 0
C++ 多线程之线程管理函数
ephemerals__
|
20天前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
29 2
ephemerals__
|
26天前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
62 5
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
68 4
ephemerals__
|
1月前
|
存储 编译器 Linux
【c++】类和对象（上）（类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针）
本文介绍了C++中的类和对象，包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用，以及如何使用访问限定符控制成员的访问权限。此外，还讨论了对象的内存分配规则和this指针的使用场景，帮助读者深入理解面向对象编程的核心概念。
ephemerals__
77 4