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

在宝安等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供网站建设、网站制作 网站设计制作定制开发,公司网站建设,企业网站建设,成都品牌网站建设,营销型网站建设,成都外贸网站建设,宝安网站建设费用合理。

单例懒汉式和多线程问题


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

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

点击(此处)折叠或打开

1. #include

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:"<

25.       cout<<"b:"<

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<

64.     single_ins::pfree();

66. }

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

点击(此处)折叠或打开

1. #include

2. #include

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:"<

32.                         cout<<"b:"<

33.                         cout<

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<

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

2. #include

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:"<

33.                         cout<<"b:"<

34.                         cout<

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<

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++如何解决单例懒汉式和多线程问题
新闻来源：http://kswjz.com/article/isghoc.html