IT评测·应用市场-qidao123.com技术社区

标题: valgrind & 单例模式的自动释放（多线程） [打印本页]

---

作者: 河曲智叟    时间: 2024-10-9 04:13
标题: valgrind & 单例模式的自动释放（多线程）
单例模式，其中对象是由_pInstance指针来保存的，而在利用单例设计模式的过程中，也难免会碰到内存泄漏的题目。那么是否有一个方法，可以让对象自动释放，而不需要程序员自己手动去释放呢？ ——嵌套类
5.1、内存泄漏的检测工具valgrind

安装

1. sudo apt install valgrind

复制代码

利用

[外链图片转存中…(img-Onqi9PtX-1728058419413)]
5.2、单例模式自动释放的四种方法 & 多线程

1、友元类

[外链图片转存中…(img-yl7twkoI-1728058419413)]
[外链图片转存中…(img-epIiJsLR-1728058419414)]

1. #include <iostream>
3. using std::cout;
4. using std::endl;
6. class Singleton
7. {
8.     friend class AutoRelease;
9. public:
10.     static Singleton *getInstance()
11.     {
12.         if(nullptr == _pInstance)
13.         {
14.             _pInstance = new Singleton();
15.         }
17.         return _pInstance;
18.     }
20.     static void destroy()
21.     {
22.         if(_pInstance)
23.         {
24.             delete _pInstance;
25.             _pInstance =nullptr;
26.         }
27.     }
29. private:
30.     Singleton()
31.     {
32.         cout << "Singleton()" << endl;
33.     }
35.     ~Singleton()
36.     {
37.         cout << "~Singleton()" << endl;
38.     }
39. private:
40.     static Singleton *_pInstance;
41. };
42. Singleton *Singleton::_pInstance = nullptr;
44. class AutoRelease
45. {
46. public:
47.     AutoRelease()
48.     {
49.         cout << "AutoRelease()" << endl;
50.     }
52.     ~AutoRelease()
53.     {
54.         cout << "~AutoRelease()" << endl;
55.         if(Singleton::_pInstance)
56.         {
57.             delete Singleton::_pInstance;
58.             Singleton::_pInstance =nullptr;
59.         }
61.     }
62. };
63. int main(int argc, char **argv)
64. {
65.     Singleton *ps1 = Singleton::getInstance();
66.     AutoRelease ar;//栈对象
68.     /* ps1->destroy(); */
69.     return 0;
70. }

复制代码

2、内部类 + 静态数据成员

[外链图片转存中…(img-oCRKHufV-1728058419414)]

• 若_ar界说为类成员，则会死锁：
  
  
  
  • new Singleton()，导致_ar在创建的单例堆对象内部，无法使其自动创建&析构（析构自身前，进行delete _pInstance）
    
  • 应将_ar界说为static
    
  • [外链图片转存中…(img-8lWGqW65-1728058419414)]
    
  
  

1. #include <iostream>
3. using std::cout;
4. using std::endl;
6. // 2、内部类 + 静态数据成员
8. class Singleton
9. {
10. public:
11.     static Singleton *getInstance()
12.     {
13.         if (_pInstance == nullptr)
14.         {
15.             _pInstance = new Singleton(); // 构造函数
16.             // _ar;
17.         }
19.         return _pInstance;
20.     }
22.     static void destroy()
23.     {
24.         if (_pInstance)
25.         {
26.             delete _pInstance;
27.             _pInstance = nullptr;
28.         }
29.     }
31. private:
32.     class AutoRelease
33.     {
34.     public:
35.         AutoRelease()
36.         {
37.             cout << "AutoRelease()" << endl;
38.         }
40.         ~AutoRelease()
41.         {
42.             cout << "~AutoRelease()" << endl;
43.             if (_pInstance)
44.             {
45.                 delete _pInstance;
46.                 _pInstance = nullptr;
47.             }
48.         }
49.     };
51. private:
52.     Singleton()
53.     {
54.         cout << "Singleton()" << endl;
55.     }
57.     ~Singleton()
58.     {
59.         cout << "~Singleton()" << endl;
60.     }
62. private:
63.     static Singleton *_pInstance; // 前向声明；定义为static，位于全局静态区（不属于本类！）
64.     static AutoRelease _ar; // 前向声明；对象数据成员, _ar不能存在堆上，否则死锁；定义为static，位于全局静态区（不属于本类！）
65. };
67. Singleton *Singleton::_pInstance = nullptr; // 静态对象必须在类外进行正式声明！
68. Singleton::AutoRelease Singleton::_ar; // 静态对象必须在类外进行正式声明！
70. int main(int argc, char **argv)
71. {
72.     Singleton *ps1 = Singleton::getInstance();
73.     /* Singleton::AutoRelease ar;//栈对象 */
75.     /* ps1->destroy(); */
76.     return 0;
77. }
79. /*
80. AutoRelease()
81. Singleton()
82. ~AutoRelease()
83. ~Singleton()
85. */

复制代码

采用模板

• Singleton.h
  

1. #ifndef __WD_TEMPLATE_SINGLETON_H__
2. #define __WD_TEMPLATE_SINGLETON_H__
4. #include <iostream>
5. using std::cout;
6. using std::endl;
7. #if 0
8. class Singleton
9. {
10. public:
11.     static Point *getInstance(int ix, int iy)
12.     {
13.                 if(nullptr == _pInstance)
14.         {
15.                         _pInstance = new Point(ix, iy);
16.                         _ar;//为了在模板参数推导时创建ar对象
17.                 }
18.                 return _pInstance;
20.     }
21. };
22. #endif
23. template <class T>
24. class Singleton
25. {
26. public:
27.         template <class... Args>
28.         static T *getInstance(Args... args)
29.         {
30.                 if (nullptr == _pInstance)
31.                 {
32.                         _pInstance = new T(args...);
33.                         _ar; // 为了在模板参数推导时创建ar对象
34.                 }
35.                 return _pInstance;
36.         }
38. private:
39.         class AutoRelease
40.         {
41.         public:
42.                 AutoRelease()
43.                 {
44.                         cout << "AutoRelease()" << endl;
45.                 }
47.                 ~AutoRelease()
48.                 {
49.                         cout << "~AutoRelease()" << endl;
50.                         if (_pInstance)
51.                         {
52.                                 delete _pInstance;
53.                                 _pInstance = nullptr;
54.                         }
55.                 }
56.         };
58. private:
59.         Singleton()
60.         {
61.                 cout << "Singleton()" << endl;
62.                 /* _ar; */
63.         }
65.         ~Singleton()
66.         {
67.                 cout << "~Singleton()" << endl;
68.         }
70. private:
71.         static T *_pInstance;// 前向声明；定义为static，位于全局静态区（不属于本类！）
72.         static AutoRelease _ar;// 前向声明；对象数据成员, _ar不能存在堆上，否则死锁；定义为static，位于全局静态区（不属于本类！）
73. };
75. template <class T>
76. T *Singleton<T>::_pInstance = nullptr; // 静态对象必须在类外进行正式声明！
78. template <class T>
79. typename Singleton<T>::AutoRelease Singleton<T>::_ar;  // 静态对象必须在类外进行正式声明！ // typename表名是一个类型
81. #endif

复制代码

• Test.cpp
  
  
  
  • 1. #include "Singleton.h"
    3. #include <iostream>
    4. using std::cout;
    5. using std::endl;
    8. class Point
    9. {
    10. public:
    11.         Point(int ix = 0, int iy = 0)
    12.         : _ix(ix)
    13.         , _iy(iy)
    14.         {       
    15.         cout << "Point(int = 0,int = 0)" << endl;       
    16.     }
    18.         void print() const
    19.         {
    20.                 cout << "(" << _ix
    21.                          << "," << _iy
    22.                          << ")" << endl;
    23.         }
    25.         ~Point()
    26.         {
    27.                 cout << "~Point()" << endl;
    28.         }
    30. private:
    31.         int _ix;
    32.         int _iy;
    33. };
    35. int main()
    36. {
    37.         Point *pt1 = Singleton<Point>::getInstance(1, 2);
    38.         Point *pt2 = Singleton<Point>::getInstance(3, 4);
    39.         pt1->print();
    40.         pt2->print();
    42.         cout << "p1 = " << pt1 << endl
    43.                  << "p2 = " << pt2 << endl;
    45.         return 0;
    46. }

    复制代码
  
  

3、饿汉模式 + atexit

atexit

[外链图片转存中…(img-M9pmTrsb-1728058419415)]

1. #include <stdlib.h>
2. #include <iostream>
4. using std::cout;
5. using std::endl;
7. void func()
8. {
9.     cout << "void func()" << endl;
10. }
12. void test()
13. {
14.     atexit(func); // atexit: 进程正常结束时候，注册的func会被执行，注册几次就会执行几次
15.     atexit(func);
16.     atexit(func);
17.     atexit(func);
18.     atexit(func);
19. }
21. int main(int argc, char **argv)
22. {
23.     cout << "start test..." << endl;
24.     test();
25.     cout << "finish test..." << endl;
27.     return 0;
28. }
30. /*
31. start test...
32. finish test...
33. void func()
34. void func()
35. void func()
36. void func()
37. void func()
39. */

复制代码

饿汉模式 + atexit

[外链图片转存中…(img-tBQqgF0g-1728058419415)]
[外链图片转存中…(img-ruQk952y-1728058419415)]

1. #include <stdlib.h>
2. #include <iostream>
4. using std::cout;
5. using std::endl;
7. // 3、atexit + 饿汉模式
9. class Singleton
10. {
11. public:
12.     static Singleton *getInstance()
13.     {
14.         // 在多线程情况下，是不安全的
15.         if (_pInstance == nullptr)
16.         {
17.             _pInstance = new Singleton(); // 构造函数
18.             atexit(destroy);              // 使用atexit：注册函数destroy一次, 当进程正常结束后，会调用一次注册的函数destroy
19.         } else {
20.             cout << "_pInstance != nullptr" << endl;
21.         }
23.         return _pInstance;
24.     }
26.     static void destroy()
27.     {
28.         if (_pInstance)
29.         {
30.             delete _pInstance;
31.             _pInstance = nullptr;
32.         }
33.     }
35. private:
36.     Singleton()
37.     {
38.         cout << "Singleton()" << endl;
39.     }
41.     ~Singleton()
42.     {
43.         cout << "~Singleton()" << endl;
44.     }
46. private:
47.     static Singleton *_pInstance;
48. };
50. /* Singleton *Singleton::_pInstance = nullptr; //饱（懒）汉模式， 问题：多线程下，单例模式失效；*/
51. Singleton *Singleton::_pInstance = getInstance(); // 饿汉模式，可解决多线程不安全问题
53. void *func1(void *arg)
54. {
55.     Singleton::getInstance();
56. }
58. void *func2(void *arg)
59. {
60.     Singleton::getInstance();
61. }
63. void *func3(void *arg)
64. {
65.     Singleton::getInstance();
66. }
67. int main(int argc, char **argv)
68. {
69.     Singleton *ps1 = Singleton::getInstance();
71.     // 饱（懒）汉模式下，多线程不安全；-- 解决：使用饿汉模式
72.     // pthread_t th1, th2, th3;
73.     // pthread_create(&th1, nullptr, func1, nullptr);
74.     // pthread_create(&th2, nullptr, func2, nullptr);
75.     // pthread_create(&th3, nullptr, func3, nullptr);
77.     return 0;
78. }

复制代码

4、多线程场景：pthread_once + atexit

[外链图片转存中…(img-MvIJXvC9-1728058419415)]

1. #include <pthread.h>
2. #include <stdlib.h>
3. #include <iostream>
5. using std::cout;
6. using std::endl;
8. //4、atexit + pthread_once
9. //有平台问题，只能在Linux下使用
11. class Singleton
12. {
13. public:
14.     static Singleton *getInstance()
15.     {
16.         //当第一个参数是某个固定值的时候，可以保证第一个参数只会被
17.         //调用一次  call_once
18.         pthread_once(&_once, init);
20.         return _pInstance;
21.     }
23.     static void init()
24.     {
25.         _pInstance = new Singleton();//构造函数
26.         atexit(destroy);
27.     }
29.     static void destroy()
30.     {
31.         if(_pInstance)
32.         {
33.             delete _pInstance;
34.             _pInstance = nullptr;
35.         }
36.     }
39. private:
40.     Singleton()
41.     {
42.         cout << "Singleton()" << endl;
43.     }
45.     ~Singleton()
46.     {
47.         cout << "~Singleton()" << endl;
48.     }
49. private:
50.     static Singleton *_pInstance;
51.     static pthread_once_t _once;
52. };
54. Singleton *Singleton::_pInstance = nullptr; //饱（懒）汉模式
55. /* Singleton *Singleton::_pInstance = getInstance();//饿汉模式 */
56. pthread_once_t Singleton::_once = PTHREAD_ONCE_INIT;
58. int main(int argc, char **argv)
59. {
60.     Singleton *ps1 = Singleton::getInstance();
62.     return 0;
63. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 IT评测·应用市场-qidao123.com技术社区 (https://dis.qidao123.com/)

Powered by Discuz! X3.4