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

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

单例懒汉式和多线程问题


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

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

点击(此处)折叠或打开

1. #include
   

2. using namespace std;
   

3. 
   

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. }
    

21. 
    

22. void print()
    

23. {
    

24. cout<<"a:"<

25. cout<<"b:"<

26. }
    

27. 
    

28. 
    

29. static single_ins* setp()
    

30. {
    

31. //?
    

32. if(myc == NULL)
    

33. {
    

34. myc = new single_ins;
    

35. }
    

36. //?
    

37. return myc;
    

38. }
    

39. 
    

40. static void pfree()
    

41. {
    

42. if(myc != NULL)
    

43. {
    

44. delete myc;
    

45. myc = NULL;
    

46. }
    

47. }
    

48. 
    

49. };
    

50. 
    

51. //? init static value
    

52. single_ins* single_ins::myc = NULL;
    

53. //nit static value
    

54. //single_ins* single_ins::myc = new single_ins;
    

55. 
    

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();
    

62. 
    

63. cout<

64. single_ins::pfree();
    

65. 
    

66. }

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

点击(此处)折叠或打开

1. #include
   

2. #include
   

3. using namespace std;
   

4. 
   

5. 
   

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. }
    

28. 
    

29. void print()
    

30. {
    

31. cout<<"a:"<

32. cout<<"b:"<

33. cout<

34. }
    

35. 
    

36. 
    

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. };
    

57. 
    

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;
    

70. 
    

71. inp = single_ins::setp();
    

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

73. inp->print();
    

74. cout<

75. return NULL;
    

76. }
    

77. 
    

78. 
    

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();
    

91. 
    

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
   

2. #include
   

3. using namespace std;
   

4. 
   

5. pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
   

6. 
   

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. }
    

29. 
    

30. void print()
    

31. {
    

32. cout<<"a:"<

33. cout<<"b:"<

34. cout<

35. }
    

36. 
    

37. 
    

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. };
    

63. 
    

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. */
    

73. 
    

74. 
    

75. 
    

76. void* main21(void* argc)
    

77. {
    

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

79. 
    

80. inp = single_ins::setp();
    

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

82. inp->print();
    

83. cout<

84. return NULL;
    

85. }
    

86. 
    

87. 
    

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();
    

100. 
     

101. }

跑出的结果如下：

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


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


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

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