C++如何解决单例懒汉式和多线程问题

这篇文章主要为大家展示了“c++如何解决单例懒汉式和多线程问题”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“C++如何解决单例懒汉式和多线程问题”这篇文章吧。

单例懒汉式和多线程问题


作为单例模式，是在整个程序运行期间只会建立一份内存空间，为了达到这个目标
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;
    

64. void* main21(void* arGC)
    

65. {
    

66.         single_ins* inp = (single_ins*)argc;
    

68.         inp = single_ins::setp();
    

69.         inp->setval(10,20);
    

70.         inp->print();
    

71.         cout<<inp<<"\n";
    

72.         return NULL;
    

73. }
    

76. int main(void)
    

77. {
    

78.         pthread_t tid;
    

79.         single_ins* a[3] = {NULL};
    

80.         void* tret[3] = {NULL};
    

81.         for(int i = 0 ; i<3; i++)
    

82.         {
    

83.                 pthread_create(&tid,NULL,main21,(void*)a[i]);
    

84.                 //pthread_join(tid, &(tret[i]));
    

85.         }
    

86.         sleep(50);
    

87.         single_ins::pfree();
    

89. }

会跑出结果
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. 
    

73. void* main21(void* argc)
    

74. {
    

75.         single_ins* inp = (single_ins*)argc;
    

77.         inp = single_ins::setp();
    

78.         inp->setval(10,20);
    

79.         inp->print();
    

80.         cout<<inp<<"\n";
    

81.         return NULL;
    

82. }
    

85. int main(void)
    

86. {
    

87.         pthread_t tid;
    

88.         single_ins* a[3] = {NULL};
    

89.         void* tret[3] = {NULL};
    

90.         for(int i = 0 ; i<3; i++)
    

91.         {
    

92.                 pthread_create(&tid,NULL,main21,(void*)a[i]);
    

93.                 //pthread_join(tid, &(tret[i]));
    

94.         }
    

95.         sleep(50);
    

96.         single_ins::pfree();
    

98. }

跑出的结果如下：

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


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


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

               

以上是“C++如何解决单例懒汉式和多线程问题”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注编程网其他教程频道！