一个简单的内存池

素颜马尾好姑娘i 2022-07-13 20:28 130阅读 0赞

为什仫要使用内存池?

1.通常我们用new/delete和malloc/free来管理内存,可能会需要频繁的调用内存,减少运行时间,增加效率.

2.避免内存碎片

传统的new/delete的弊端>

1.分配内存时要查看空闲分区表，根据一定的算法来分配，比如最佳适应算法，最差适应算法...,然后更新空闲分区表.释放的时候，也需要在空闲分区表中加入该释放的内存，如果上下也是空闲的还需要将内存碎片合并为一个大的空闲分区 .

2.默认的内存管理函数还考虑了多线程的应用，增加了开销.

3.频繁的申请和释放还将导致内存碎片.

内存池是在真正使用内存之前，先申请一个大的内存块.当需要使用内存时，就从内存池中分配一块使用，当使用完了不用还给操作系统而是还给内存池。如果内存池不够就向内存申请一块更大的内存块.

存在内存池的好处?

1.因为申请的内存都比较大，所以降低了外部碎片(内存碎片).

2.因为是一次性申请一块较大的内存，避免了频繁的向内存的请求操作，提高了内存的分配效率，避免内存泄漏.

**内碎片**

分配内存时的大小比需求的内存大，有部分内存未使用，这块未使用的内存就称为内碎片

**外碎片/内存碎片**

当空闲的存储器的和计起来足够满足一个分配请求，但是没有一个单独的空闲块足够大可以处理这个请求

![Center][]

![Center 1][]

下面介绍一种高效的内存池,它的实现类似链表，链表上的每个结点都是一个对象池，如果申请对象则去内存池中申请，归还的时候还给内存池即可.

![Center 2][]

#pragma once
    
    #include<vector>
    #include<string>
    
    template<class T>
    class ObjectPool
    {
    	struct BlockNode
    	{
    		void *_memory;     //内存块
    		BlockNode *_next;
    		size_t _objNum;    //内存对象的个数
    		BlockNode(size_t objNum)
    			:_objNum(objNum)
    			,_next(NULL)
    		{
    			_memory=malloc(_itemSize*objNum);
    		}
    		~BlockNode()
    		{
    			free(_memory);
    		}
    	};
    protected:
    	size_t _countIn;        //当前结点的计数
    	BlockNode *_first;
    	BlockNode *_last;
    	size_t _maxNum;         //结点申请内存块对象的个数
    	static size_t _itemSize;    //单个对象的大小
    	T *_lastDelete;
    public:
    	ObjectPool(size_t initNum=32,size_t maxNum=1000000)
    		:_countIn(0)
    		,_maxNum(maxNum)
    		,_lastDelete(NULL)
    	{
    		_first=_last=new BlockNode(initNum);
    	}
    	~ObjectPool()
    	{
    		Destroy();
    	}
    	void Destroy()
    	{
    		BlockNode *cur=_first;
    		while (cur)
    		{
    			BlockNode *del=cur;
    			cur=cur->_next;
    			delete del;
    		}
    		_first=_last=NULL;
    	}
    	T* New()
    	{
    		if(_lastDelete)
    		{
    			//优先考虑以前释放的空间
    			T *obj=_lastDelete;
    			_lastDelete=*((T **)_lastDelete);
    			return new(obj)T;
    		}
    		if(_countIn >= _last->_objNum)   //申请新的结点和对象
    		{
    			size_t size=2*_countIn;
    			if(size > _maxNum)
    				size=_maxNum;
    			_last->_next=new BlockNode(size);
    			_last=_last->_next;
    			_countIn=0;
    		}
    		T *obj=(T *)((char *)_last->_memory + _countIn*_itemSize);
    		_countIn++;
    		return new(obj)T();
    	}
    	void Delete(T *ptr)
    	{
    		if(ptr)
    		{
    			ptr->~T();
    			*((T **)ptr)=_lastDelete;
    			_lastDelete=ptr;
    		}
    	}
    protected:
    	static size_t GetItemSize()
    	{
    		if(sizeof(T) > sizeof(T *))
    			return sizeof(T);
    		else
    			return sizeof(T *);
    	}
    };
    template<class T>
    size_t ObjectPool<T>::_itemSize=ObjectPool<T>::GetItemSize();

over~~~

[Center]: /images/20220714/be4574474fa54fac8299c2a417adc681.png
[Center 1]: /images/20220714/a4a94fad271b4cb4add8fef3e42ed751.png
[Center 2]: /images/20220714/517d9699e9164bccadad6b01dd96a9ea.png