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

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

2017-04-10 1046
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 单例懒汉式和多线程问题 作为单例模式，是在整个程序运行期间只会建立一份内存空间，为了达到这个目标 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++线程
单例线程
线程mutex
C++多线程
C++ mutex
重庆八怪
目录
相关文章
小狮子安度因1
|
2月前
|
Java 调度
基于C++11的线程池
基于C++11的线程池
小狮子安度因1
80 1
智物科技库
|
2月前
|
安全 Java C#
Spring创建的单例对象，存在线程安全问题吗？
Spring框架提供了多种Bean作用域，包括单例（Singleton）、原型（Prototype）、请求（Request）、会话（Session）、全局会话（GlobalSession）等。单例是默认作用域，保证每个Spring容器中只有一个Bean实例；原型作用域则每次请求都会创建一个新的Bean实例；请求和会话作用域分别与HTTP请求和会话绑定，在Web应用中有效。 单例Bean在多线程环境中可能面临线程安全问题，Spring容器虽然确保Bean的创建过程是线程安全的，但Bean的使用安全性需开发者自行保证。保持Bean无状态是最简单的线程安全策略；
智物科技库
52 0
热爱技术的小郑
|
2月前
|
算法 Java 调度
【多线程面试题二十】、 如何实现互斥锁（mutex）？
这篇文章讨论了在Java中实现互斥锁（mutex）的两种方式：使用`synchronized`关键字进行块结构同步，以及使用`java.util.concurrent.locks.Lock`接口进行非块结构同步，后者提供了更灵活的同步机制和扩展性。
热爱技术的小郑
37 0
呆呆宝
|
3月前
|
C++ 运维
开发与运维编译问题之在C++中在使用std::mutex后能自动释放锁如何解决
开发与运维编译问题之在C++中在使用std::mutex后能自动释放锁如何解决
呆呆宝
53 2
呆呆宝
|
3月前
|
算法 编译器 C++
开发与运维线程问题之在C++的原子操作中memory_order如何解决
开发与运维线程问题之在C++的原子操作中memory_order如何解决
呆呆宝
36 2
嘟嘟嘟嘟嘟嘟
|
2月前
|
Dart 编译器 API
Dart ffi 使用问题之在C++线程中无法直接调用Dart函数的问题如何解决
Dart ffi 使用问题之在C++线程中无法直接调用Dart函数的问题如何解决
嘟嘟嘟嘟嘟嘟
49 0
嘟嘟嘟嘟嘟嘟
|
2月前
|
Dart API C语言
Dart ffi 使用问题之想在C/C++中创建异步线程来调用Dart方法，如何操作
Dart ffi 使用问题之想在C/C++中创建异步线程来调用Dart方法，如何操作
嘟嘟嘟嘟嘟嘟
46 0
竹子爱熊猫
|
2月前
|
设计模式 SQL 安全
单例模式大全：细说七种线程安全的Java单例实现，及数种打破单例的手段！
设计模式，这是编程中的灵魂，用好不同的设计模式，能使你的代码更优雅/健壮、维护性更强、灵活性更高，而众多设计模式中最出名、最广为人知的就是Singleton Pattern单例模式。通过单例模式，我们就可以避免由于多个实例的创建和销毁带来的额外开销，本文就来一起聊聊单例模式。
竹子爱熊猫
48 0
萝卜丝丸子
|
3月前
|
Rust 安全 程序员
Rust与C++的区别及使用问题之Rust解决多线程下的共享的问题如何解决
Rust与C++的区别及使用问题之Rust解决多线程下的共享的问题如何解决
萝卜丝丸子
40 0
萝卜丝丸子
|
3月前
|
Rust 编译器 程序员
Rust与C++的区别及使用问题之Rust避免多线程中的lifetime的问题如何解决
Rust与C++的区别及使用问题之Rust避免多线程中的lifetime的问题如何解决
萝卜丝丸子
27 0