java 内存池实现_内存池的原理及实现

在软件开发中，有些对象使用非常频繁，那么我们可以预先在堆中实例化一些对象，我们把维护这些对象的结构叫“内存池”。在需要用的时候，直接从内存池中拿，而不用重新实例化，在要销毁的时候，不是直接free/delete，而是返还给内存池。

把那些常用的对象存在内存池中，就不用频繁的分配/回收内存，可以相对减少内存碎片，更重要的是实例化这样的对象更快，回收也更快。当内存池中的对象不够用的时候就扩容。

我的内存池实现如下：

#pragma once#include templatestruct ProxyT{     ProxyT():next(NULL){}     T data;    ProxyT* next;};templateclass MemoryPool{public:    static void* New()    {        if(next==NULL)        {            Alloc();        }        assert(next!=NULL);        ProxyT* cur=next;        next=next->next;        return cur;    }    static void Delete(void* ptr)    {        ProxyT* cur=static_cast*>(ptr);        cur->next=next;        next=cur;     }#ifdef CanFree    static void Clear()    {        ProxyT* 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* tmpProxy=new ProxyT();            next=tmpProxy;            for(int i=1;inext=new ProxyT();                tmpProxy=tmpProxy->next;            }         #else            ProxyT* memory=(ProxyT*)malloc(size*sizeof(ProxyT));            ProxyT* tmpProxy=new (memory) ProxyT();            next=tmpProxy;            for (size_t i=1;inext=new (memory+i) ProxyT();                tmpProxy=tmpProxy->next;            }        #endif        }    }     static ProxyT* next;     MemoryPool();    MemoryPool(const MemoryPool&);};template ProxyT* MemoryPool::next=NULL; #define NewAndDelete(className)             static void* operator new(size_t size)      {                                               return MemoryPool::New();    }                                           static void operator delete(void* ptr)      {                                               MemoryPool::Delete(ptr);     }

#include "stdafx.h" #define CanFree#include "MemoryPool.h" struct A{     int i;     NewAndDelete(A) };  int _tmain(int argc, _TCHAR* argv[]){            {         vector vect;        for(int i=0;i<16;i++)        {            A* a=new A();            a->i=i;            vect.push_back(a);        }        for(int i=0;ii<=0;i--)        {            delete vect[i];        }        vect.clear();                MemoryPool::Clear();    }       system("pause");    return 0; }

运行结果如下图：

不到100行代码，有两个public方法New和Delete；还有一个Clear方法，这个方法的存在取决于是否定义了宏CanFree，如果定义了这个宏，那么对象是一个个的实例化，在调用Clear的时候可以一个个的回收，如果没有定义，那么是一次分配一块较大的内存，然后在这块内存上实例化多个对象，但没有实现回收这块内存的方法，如果要回收这样的大块内存块，就必须将这些内存块的首地址存起来，我这里没有存起来，而且还要标记对象是否使用，那么Proxy还要加一个字段表示是否使用，在回收的时候还要判断所有对象是否没有使用，只有都没使用才能回收，妹的，为了回收弄得这么麻烦，话说你为什么要回收内存池呢，于是就没有实现回收的方法。整个内存池其实就是一个单链表，表头指向第一个没有使用节点，我们可以把这个单链表想象成一段链条，调用方法New就是从链条的一端(单链表表头)取走一节点，调用方法Delete就是在链条的一端(单链表表头)前面插入一个节点，新插入的节点就是链表的表头，这样New和Delete的时间复杂度都是O(1)，那叫一个快。

所有要使用内存池的对象，只需要在这个对象中引入宏NewAndDelete，这个宏其实就是重写对象的new和delete方法，让对象的创建和回收都通过内存池来实现，所有用内存池实现的对象使用起来和别的对象基本上是一样，唯一的一个问题就是内存池对象对象不是线程安全的，在多线程编程中，创建一个对象时必须枷锁。如果在New和Delete的实现中都加个锁，我又觉得他太影响性能，毕竟很多时候是不需要枷锁，有些对象可能有不用于多线程，对于这个问题，求高手指点！