内存池的原理及实现

jimu

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

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

我的内存池实现如下：

1. #pragma once
   
2. #include <assert.h>
   
3. 
   
4. template<typename T>
   
5. struct ProxyT
   
6. {
   
7.     ProxyT():next(NULL){}
   
8.     T data;
   
9.     ProxyT* next;
   
10. };
    
11. 
    
12. template<typename T>
    
13. class MemoryPool
    
14. {
    
15. public:
    
16.     static void* New()
    
17.     {
    
18.         if(next==NULL)
    
19.         {
    
20.             Alloc();
    
21.         }
    
22.         assert(next!=NULL);
    
23.         ProxyT<T>* cur=next;
    
24.         next=next->next;
    
25.         return cur;
    
26.     }
    
27. 
    
28.     static void Delete(void* ptr)
    
29.     {
    
30.         ProxyT<T>* cur=static_cast<ProxyT<T>*>(ptr);
    
31.         cur->next=next;
    
32.         next=cur;
    
33.     }
    
34. 
    
35. #ifdef CanFree
    
36.     static void Clear()
    
37.     {
    
38.         ProxyT<T>* proxy=NULL;
    
39.         while(next!=NULL)
    
40.         {
    
41.             proxy=next->next;
    
42.             delete next;
    
43.             next=proxy->next;
    
44.         }
    
45.         next=NULL;
    
46.     }
    
47. #endif
    
48.    
    
49. private:
    
50.     static void Alloc(size_t size=16)
    
51.     {
    
52.         if(next==NULL)
    
53.         {
    
54.         #ifdef CanFree
    
55.             ProxyT<T>* tmpProxy=new ProxyT<T>();
    
56.             next=tmpProxy;
    
57.             for(int i=1;i<size;i++)
    
58.             {
    
59.                 tmpProxy->next=new ProxyT<T>();
    
60.                 tmpProxy=tmpProxy->next;
    
61.             }
    
62.         #else
    
63.             ProxyT<T>* memory=(ProxyT<T>*)malloc(size*sizeof(ProxyT<T>));
    
64.             ProxyT<T>* tmpProxy=new (memory) ProxyT<T>();
    
65.             next=tmpProxy;
    
66.             for (size_t i=1;i<size;i++)
    
67.             {
    
68.                 tmpProxy->next=new (memory+i) ProxyT<T>();
    
69.                 tmpProxy=tmpProxy->next;
    
70.             }
    
71.         #endif
    
72. 
    
73.         }
    
74.     }
    
75. 
    
76.     static ProxyT<T>* next;
    
77.     MemoryPool<T>();
    
78.     MemoryPool<T>(const MemoryPool<T>&);
    
79. };
    
80. 
    
81. template<typename T> ProxyT<T>* MemoryPool<T>::next=NULL;
    
82. 
    
83. #define NewAndDelete(className)             \
    
84. static void* operator new(size_t size)      \
    
85. {                                           \
    
86.     return MemoryPool<className>::New();    \
    
87. }                                           \
    
88. static void operator delete(void* ptr)      \
    
89. {                                           \
    
90.     MemoryPool<className>::Delete(ptr);     \
    
91. }

复制代码

测试代码如下：

1. #include "stdafx.h"
   
2. #define CanFree
   
3. #include "MemoryPool.h"
   
4. 
   
5. struct A
   
6. {
   
7.     int i;
   
8.     NewAndDelete(A)
   
9. };
   
10.   
    
11. int _tmain(int argc, _TCHAR* argv[])
    
12. {   
    
13.      
    
14.     {
    
15.         vector<A*> vect;
    
16.         for(int i=0;i<16;i++)
    
17.         {
    
18.             A* a=new A();
    
19.             a->i=i;
    
20.             vect.push_back(a);
    
21.         }
    
22.         for(int i=0;i<vect.size();i++)
    
23.         {
    
24.             cout<<vect[i]->i<<endl;
    
25.         }
    
26.         for(int i=vect.size()-1;i>=0;i--)
    
27.         {
    
28.             delete vect[i];
    
29.         }
    
30.         vect.clear();
    
31.         
    
32.         MemoryPool<A>::Clear();
    
33.     }
    
34.    
    
35.     system("pause");
    
36.     return 0;
    
37. }

复制代码

运行结果如下图：

不到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