内存池的原理及实现
在软件开发中,有些对象使用非常频繁,那么我们可以预先在堆中实例化一些对象,我们把维护这些对象的结构叫“内存池”。在需要用的时候,直接从内存池中拿,而不用从新实例化,在要销毁的时候,不是直接free/delete,而是返还给内存池。把那些常用的对象存在内存池中,就不用频繁的分配/回收内存,可以相对减少内存碎片,更重要的是实例化这样的对象更快,回收也更快。当内存池中的对象不够用的时候就扩容。我的内存池实现如下:#pragma once#include <assert.h>
template<typename T>
struct ProxyT
{
ProxyT():next(NULL){}
T data;
ProxyT* next;
};
template<typename T>
class MemoryPool
{
public:
static void* New()
{
if(next==NULL)
{
Alloc();
}
assert(next!=NULL);
ProxyT<T>* cur=next;
next=next->next;
return cur;
}
static void Delete(void* ptr)
{
ProxyT<T>* cur=static_cast<ProxyT<T>*>(ptr);
cur->next=next;
next=cur;
}
#ifdef CanFree
static void Clear()
{
ProxyT<T>* proxy=NULL;
while(next!=NULL)
{
proxy=next->next;
delete next;
next=proxy->next;
}
next=NULL;
}
#endif
private:
static void Alloc(size_t size=16)
{
if(next==NULL)
{
#ifdef CanFree
ProxyT<T>* tmpProxy=new ProxyT<T>();
next=tmpProxy;
for(int i=1;i<size;i++)
{
tmpProxy->next=new ProxyT<T>();
tmpProxy=tmpProxy->next;
}
#else
ProxyT<T>* memory=(ProxyT<T>*)malloc(size*sizeof(ProxyT<T>));
ProxyT<T>* tmpProxy=new (memory) ProxyT<T>();
next=tmpProxy;
for (size_t i=1;i<size;i++)
{
tmpProxy->next=new (memory+i) ProxyT<T>();
tmpProxy=tmpProxy->next;
}
#endif
}
}
static ProxyT<T>* next;
MemoryPool<T>();
MemoryPool<T>(const MemoryPool<T>&);
};
template<typename T> ProxyT<T>* MemoryPool<T>::next=NULL;
#define NewAndDelete(className) \
static void* operator new(size_t size) \
{ \
return MemoryPool<className>::New(); \
} \
static void operator delete(void* ptr) \
{ \
MemoryPool<className>::Delete(ptr); \
}测试代码如下:#include "stdafx.h"
#define CanFree
#include "MemoryPool.h"
struct A
{
int i;
NewAndDelete(A)
};
int _tmain(int argc, _TCHAR* argv[])
{
{
vector<A*> vect;
for(int i=0;i<16;i++)
{
A* a=new A();
a->i=i;
vect.push_back(a);
}
for(int i=0;i<vect.size();i++)
{
cout<<vect->i<<endl;
}
for(int i=vect.size()-1;i>=0;i--)
{
delete vect;
}
vect.clear();
MemoryPool<A>::Clear();
}
system("pause");
return 0;
}运行结果如下图:http://images.cnitblog.com/blog/142192/201310/28083529-f817ff35ba6941a381ec6ab8d38730ee.png不到100行代码,有两个public方法New和Delete;还有一个Clear方法,这个方法的存在取决于是否定义了宏CanFree,如果定义了这个宏,那么对象是一个个的实例化,在调用Clear的时候可以一个个的回收,如果没有定义,那么是一次分配一块较大的内存,然后在这块内存上实例化多个对象,但没有实现回收这块内存的方法,如果要回收这样的大块内存块,就必须将这些内存块的首地址存起来,我这里没有存起来,而且还要标记对象是否使用,那么Proxy<T>还要加一个字段表示是否使用,在回收的时候还要判断所有对象是否没有使用,只有都没使用才能回收,妹的,为了回收弄得这么麻烦,话说你为什么要回收内存池呢,于是就没有实现回收的方法。整个内存池其实就是一个单链表,表头指向第一个没有使用节点,我们可以把这个单链表想象成一段链条,调用方法New就是从链条的一端(单链表表头)取走一节点,调用方法Delete就是在链条的一端(单链表表头)前面插入一个节点,新插入的节点就是链表的表头,这样New和Delete的时间复杂度都是O(1),那叫一个快。所有要使用内存池的对象,只需要在这个对象中引入宏NewAndDelete,这个宏其实就是重写对象的new和delete方法,让对象的创建和回收都通过内存池来实现,所有用内存池实现的对象使用起来和别的对象基本上是一样,唯一的一个问题就是内存池对象对象不是线程安全的,在多线程编程中,创建一个对象时必须枷锁。如果在New和Delete的实现中都加个锁,我又觉得他太影响性能,毕竟很多时候是不需要枷锁,有些对象可能有不用于多线程,对于这个问题,求高手指点!
http://www.cnblogs.com/hlxs/p/3391698.html
页:
[1]