valgrind & 单例模式的自动释放（多线程）

Lindsay.Lu丶2024-10-06 23:44

单例模式，其中对象是由_pInstance指针来保存的，而在使用单例设计模式的过程中，也难免会遇到内存泄漏的问题。那么是否有一个方法，可以让对象自动释放，而不需要程序员自己手动去释放呢？ ------嵌套类

5.1、内存泄漏的检测工具valgrind
安装
Linux 复制代码 
sudo apt install valgrind
使用

[外链图片转存中...(img-Onqi9PtX-1728058419413)]

5.2、单例模式自动释放的四种方法 & 多线程
1、友元类

[外链图片转存中...(img-yl7twkoI-1728058419413)]

[外链图片转存中...(img-epIiJsLR-1728058419414)]

c++ 复制代码 
#include <iostream>

using std::cout;
using std::endl;

class Singleton
{
    friend class AutoRelease;
public:
    static Singleton *getInstance()
    {
        if(nullptr == _pInstance)
        {
            _pInstance = new Singleton();
        }

        return _pInstance;
    }

    static void destroy()
    {
        if(_pInstance)
        {
            delete _pInstance;
            _pInstance =nullptr;
        }
    }

private:
    Singleton()
    {
        cout << "Singleton()" << endl;
    }

    ~Singleton()
    {
        cout << "~Singleton()" << endl;
    }
private:
    static Singleton *_pInstance;
};
Singleton *Singleton::_pInstance = nullptr;

class AutoRelease
{
public:
    AutoRelease()
    {
        cout << "AutoRelease()" << endl;
    }

    ~AutoRelease()
    {
        cout << "~AutoRelease()" << endl;
        if(Singleton::_pInstance)
        {
            delete Singleton::_pInstance;
            Singleton::_pInstance =nullptr;
        }

    }
};
int main(int argc, char **argv)
{
    Singleton *ps1 = Singleton::getInstance();
    AutoRelease ar;//栈对象

    /* ps1->destroy(); */
    return 0;
}
2、内部类 + 静态数据成员

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

  • 若_ar定义为类成员，则会死锁：
    • new Singleton()，导致_ar在创建的单例堆对象内部，无法使其自动创建&析构（析构自身前，进行delete _pInstance）
    • 应将_ar定义为static
    • [外链图片转存中...(img-8lWGqW65-1728058419414)]
c++ 复制代码 
#include <iostream>

using std::cout;
using std::endl;

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

class Singleton
{
public:
    static Singleton *getInstance()
    {
        if (_pInstance == nullptr)
        {
            _pInstance = new Singleton(); // 构造函数
            // _ar;
        }

        return _pInstance;
    }

    static void destroy()
    {
        if (_pInstance)
        {
            delete _pInstance;
            _pInstance = nullptr;
        }
    }

private:
    class AutoRelease
    {
    public:
        AutoRelease()
        {
            cout << "AutoRelease()" << endl;
        }

        ~AutoRelease()
        {
            cout << "~AutoRelease()" << endl;
            if (_pInstance)
            {
                delete _pInstance;
                _pInstance = nullptr;
            }
        }
    };

private:
    Singleton()
    {
        cout << "Singleton()" << endl;
    }

    ~Singleton()
    {
        cout << "~Singleton()" << endl;
    }

private:
    static Singleton *_pInstance; // 前向声明；定义为static，位于全局静态区（不属于本类！）
    static AutoRelease _ar; // 前向声明；对象数据成员, _ar不能存在堆上，否则死锁；定义为static，位于全局静态区（不属于本类！）
};

Singleton *Singleton::_pInstance = nullptr; // 静态对象必须在类外进行正式声明！
Singleton::AutoRelease Singleton::_ar; // 静态对象必须在类外进行正式声明！

int main(int argc, char **argv)
{
    Singleton *ps1 = Singleton::getInstance();
    /* Singleton::AutoRelease ar;//栈对象 */

    /* ps1->destroy(); */
    return 0;
}

/*
AutoRelease()
Singleton()
~AutoRelease()
~Singleton()

*/
采用模板
  • Singleton.h
c++ 复制代码 
#ifndef __WD_TEMPLATE_SINGLETON_H__
#define __WD_TEMPLATE_SINGLETON_H__

#include <iostream>
using std::cout;
using std::endl;
#if 0
class Singleton
{
public:
    static Point *getInstance(int ix, int iy)
    {
		if(nullptr == _pInstance) 
        {
			_pInstance = new Point(ix, iy);
			_ar;//为了在模板参数推导时创建ar对象
		}
		return _pInstance;

    }
};
#endif
template <class T>
class Singleton
{
public:
	template <class... Args>
	static T *getInstance(Args... args)
	{
		if (nullptr == _pInstance)
		{
			_pInstance = new T(args...);
			_ar; // 为了在模板参数推导时创建ar对象
		}
		return _pInstance;
	}

private:
	class AutoRelease
	{
	public:
		AutoRelease()
		{
			cout << "AutoRelease()" << endl;
		}

		~AutoRelease()
		{
			cout << "~AutoRelease()" << endl;
			if (_pInstance)
			{
				delete _pInstance;
				_pInstance = nullptr;
			}
		}
	};

private:
	Singleton()
	{
		cout << "Singleton()" << endl;
		/* _ar; */
	}

	~Singleton()
	{
		cout << "~Singleton()" << endl;
	}

private:
	static T *_pInstance;// 前向声明；定义为static，位于全局静态区（不属于本类！）
	static AutoRelease _ar;// 前向声明；对象数据成员, _ar不能存在堆上，否则死锁；定义为static，位于全局静态区（不属于本类！）
};

template <class T>
T *Singleton<T>::_pInstance = nullptr; // 静态对象必须在类外进行正式声明！

template <class T>
typename Singleton<T>::AutoRelease Singleton<T>::_ar;  // 静态对象必须在类外进行正式声明！ // typename表名是一个类型

#endif

  • Test.cpp

    c++ 复制代码 
    #include "Singleton.h"

#include <iostream>
using std::cout;
using std::endl;


class Point
{
public:
	Point(int ix = 0, int iy = 0)
	: _ix(ix)
	, _iy(iy)
	{	
        cout << "Point(int = 0,int = 0)" << endl;	
    }

	void print() const
	{
		cout << "(" << _ix
			 << "," << _iy
			 << ")" << endl;
	}

	~Point()
	{
		cout << "~Point()" << endl;
	}

private:
	int _ix;
	int _iy;
};
 
int main()
{
	Point *pt1 = Singleton<Point>::getInstance(1, 2);
	Point *pt2 = Singleton<Point>::getInstance(3, 4);
	pt1->print();
	pt2->print();

	cout << "p1 = " << pt1 << endl
		 << "p2 = " << pt2 << endl;

	return 0;
}
3、饿汉模式 + atexit
atexit

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

c++ 复制代码 
#include <stdlib.h>
#include <iostream>

using std::cout;
using std::endl;

void func()
{
    cout << "void func()" << endl;
}

void test()
{
    atexit(func); // atexit: 进程正常结束时候，注册的func会被执行，注册几次就会执行几次
    atexit(func);
    atexit(func);
    atexit(func);
    atexit(func);
}

int main(int argc, char **argv)
{
    cout << "start test..." << endl;
    test();
    cout << "finish test..." << endl;

    return 0;
}

/*
start test...
finish test...
void func()
void func()
void func()
void func()
void func()

*/
饿汉模式 + atexit

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

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

c++ 复制代码 
#include <stdlib.h>
#include <iostream>

using std::cout;
using std::endl;

// 3、atexit + 饿汉模式

class Singleton
{
public:
    static Singleton *getInstance()
    {
        // 在多线程情况下，是不安全的
        if (_pInstance == nullptr)
        {
            _pInstance = new Singleton(); // 构造函数
            atexit(destroy);              // 使用atexit：注册函数destroy一次, 当进程正常结束后，会调用一次注册的函数destroy
        } else {
            cout << "_pInstance != nullptr" << endl;
        }

        return _pInstance;
    }

    static void destroy()
    {
        if (_pInstance)
        {
            delete _pInstance;
            _pInstance = nullptr;
        }
    }

private:
    Singleton()
    {
        cout << "Singleton()" << endl;
    }

    ~Singleton()
    {
        cout << "~Singleton()" << endl;
    }

private:
    static Singleton *_pInstance;
};

/* Singleton *Singleton::_pInstance = nullptr; //饱（懒）汉模式， 问题：多线程下，单例模式失效；*/
Singleton *Singleton::_pInstance = getInstance(); // 饿汉模式，可解决多线程不安全问题

void *func1(void *arg)
{
    Singleton::getInstance();
}

void *func2(void *arg)
{
    Singleton::getInstance();
}

void *func3(void *arg)
{
    Singleton::getInstance();
}
int main(int argc, char **argv)
{
    Singleton *ps1 = Singleton::getInstance();

    // 饱（懒）汉模式下，多线程不安全；-- 解决：使用饿汉模式
    // pthread_t th1, th2, th3;
    // pthread_create(&th1, nullptr, func1, nullptr);
    // pthread_create(&th2, nullptr, func2, nullptr);
    // pthread_create(&th3, nullptr, func3, nullptr);

    return 0;
}
4、多线程场景：pthread_once + atexit

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

c++ 复制代码 
#include <pthread.h>
#include <stdlib.h>
#include <iostream>

using std::cout;
using std::endl;

//4、atexit + pthread_once
//有平台问题，只能在Linux下使用

class Singleton
{
public:
    static Singleton *getInstance()
    {
        //当第一个参数是某个固定值的时候，可以保证第一个参数只会被
        //调用一次  call_once
        pthread_once(&_once, init);

        return _pInstance;
    }

    static void init()
    {
        _pInstance = new Singleton();//构造函数
        atexit(destroy);
    }

    static void destroy()
    {
        if(_pInstance)
        {
            delete _pInstance;
            _pInstance = nullptr;
        }
    }


private:
    Singleton()
    {
        cout << "Singleton()" << endl;
    }

    ~Singleton()
    {
        cout << "~Singleton()" << endl;
    }
private:
    static Singleton *_pInstance;
    static pthread_once_t _once;
};

Singleton *Singleton::_pInstance = nullptr; //饱（懒）汉模式
/* Singleton *Singleton::_pInstance = getInstance();//饿汉模式 */
pthread_once_t Singleton::_once = PTHREAD_ONCE_INIT;

int main(int argc, char **argv)
{
    Singleton *ps1 = Singleton::getInstance();

    return 0;
}
相关推荐
拉里小猪的迷弟2 小时前
设计模式-创建型-常用：单例模式、工厂模式、建造者模式
单例模式·设计模式·建造者模式·工厂模式
GGBondlctrl3 天前
【JavaEE初阶】深入解析单例模式中的饿汉模式，懒汉模式的实现以及线程安全问题
单例模式·设计模式·饿汉模式·懒汉模式·懒汉模式线程安全问题
清风拂山感3 天前
设计模式之单例模式
javascript·单例模式·设计模式
陌上之殇3 天前
C++实现单例模式
c++·单例模式
冷白白3 天前
【C++】单例模式
开发语言·c++·单例模式·c
枪哥玩转嵌入式4 天前
大佬，简单解释下“嵌入式软件开发”和“嵌入式硬件开发”的区别
单片机·单例模式·51单片机
It'sMyGo4 天前
js设计模式-工厂模式 单例模式 观察者模式 发布订阅模式 原型模式 代理模式 迭代器模式
观察者模式·单例模式·设计模式
我与岁月的森林5 天前
继承实现单例模式的探索（二）
单例模式·c#
小狗爱世界5 天前
常用设计模式之单例模式、策略模式、工厂模式
单例模式·设计模式·策略模式
热门推荐
01【经验分享】Ubuntu22.04安装微信(linux官方版)02安卓系列机型永久去除data分区加密 详细步骤解析032024年高教社杯数学建模国赛C题超详细解题思路分析04CTF网络安全大赛简单的web抓包题目：HEADache05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07pve(Proxmox VE)安装i225v网卡驱动08苍穹外卖面试总结09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10RAG 实践- Ollama+RagFlow 部署本地知识库