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

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

2017-04-10 1179
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 单例懒汉式和多线程问题 作为单例模式，是在整个程序运行期间只会建立一份内存空间，为了达到这个目标 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
重庆八怪
目录
相关文章
石小浪♪
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念，包括进程和线程的定义、并发的实现方式，以及如何在C++中创建和管理线程，包括使用`std::thread`库、线程的join和detach方法，并通过示例代码展示了如何创建和使用多线程。
石小浪♪
249 1
C++ 多线程之初识多线程
最好zzz
|
缓存 安全 C++
C++无锁队列：解锁多线程编程新境界
【10月更文挑战第27天】
最好zzz
1062 7
潇洒洒
|
消息中间件 存储 安全
深入探索C++无锁队列：多线程编程的高效利器
【10月更文挑战第19天】
潇洒洒
1579 6
小王老师呀
|
存储 并行计算 安全
C++多线程应用
【10月更文挑战第29天】C++ 中的多线程应用广泛，常见场景包括并行计算、网络编程中的并发服务器和图形用户界面（GUI）应用。通过多线程可以显著提升计算速度和响应能力。示例代码展示了如何使用 `pthread` 库创建和管理线程。注意事项包括数据同步与互斥、线程间通信和线程安全的类设计，以确保程序的正确性和稳定性。
小王老师呀
421 5
三三是该溜子
|
缓存 安全 Java
【JavaEE】——单例模式引起的多线程安全问题：“饿汉/懒汉”模式，及解决思路和方法（面试高频）
单例模式下，“饿汉模式”，“懒汉模式”，单例模式下引起的线程安全问题，解锁思路和解决方法
三三是该溜子
573 0
石小浪♪
|
存储 前端开发 C++
C++ 多线程之带返回值的线程处理函数
这篇文章介绍了在C++中使用`async`函数、`packaged_task`和`promise`三种方法来创建带返回值的线程处理函数。
石小浪♪
690 6
石小浪♪
|
C++
C++ 多线程之线程管理函数
这篇文章介绍了C++中多线程编程的几个关键函数，包括获取线程ID的`get_id()`，延时函数`sleep_for()`，线程让步函数`yield()`，以及阻塞线程直到指定时间的`sleep_until()`。
石小浪♪
367 0
C++ 多线程之线程管理函数
平凡程序猿~
|
编译器 C++ 开发者
【C++篇】深度解析类与对象（下）
在上一篇博客中，我们学习了C++的基础类与对象概念，包括类的定义、对象的使用和构造函数的作用。在这一篇，我们将深入探讨C++类的一些重要特性，如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象，以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念，提升代码的健壮性、灵活性和可维护性。
平凡程序猿~
338 0
ephemerals__
|
11月前
|
编译器 C++ 容器
【c++11】c++11新特性（上）（列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式）
C++11为C++带来了革命性变化，引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式，initializer_list简化了容器多元素初始化；右值引用和移动语义优化了资源管理，减少拷贝开销；类新增移动构造和移动赋值函数提升性能；lambda表达式提供匿名函数对象，增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展，提升了开发效率与程序性能。
ephemerals__
440 12
hahaha无
|
9月前
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果：注意：类模板中的成员函数若是放在类外定义时，需要加模板参数列表。return 0;
hahaha无
235 0