内存池简单实例

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <time.h>
   
4. #include <iostream>
   
5. 
   
6. using namespace std;
   
7. 
   
8. class MemPool
   
9. {
   
10.   public:
    
11.      MemPool();
    
12.      ~MemPool();
    
13.      void* Alloc();
    
14.      void Free(void* p);
    
15.      
    
16.   private:
    
17.       const static int blockSize = 1024;
    
18.       const static int itemSize = 16;
    
19.       
    
20.       struct ItemNode
    
21.       {
    
22.              ItemNode *next;
    
23.              char data[itemSize - sizeof(ItemNode*)];
    
24.       };
    
25.       
    
26.       struct BlockNode
    
27.       {
    
28.              BlockNode *next;
    
29.              ItemNode data[blockSize/itemSize];
    
30.       };
    
31.       
    
32.       ItemNode *freeItemNodeHead;
    
33.       BlockNode *memBlockNodeHead;
    
34. };
    
35. 
    
36. MemPool::MemPool():memBlockNodeHead(NULL), freeItemNodeHead(NULL)
    
37. {
    
38. }
    
39. 
    
40. MemPool::~MemPool()
    
41. {    
    
42.     BlockNode *temp = memBlockNodeHead;
    
43.      while(temp)
    
44.      {
    
45.         memBlockNodeHead = memBlockNodeHead->next;
    
46.         delete temp;
    
47.         temp = memBlockNodeHead;
    
48.     }
    
49. }
    
50. 
    
51. void* MemPool::Alloc()
    
52. {
    
53.       if(freeItemNodeHead == NULL)
    
54.       {
    
55.          BlockNode *tempBlockNode = new BlockNode;
    
56.          if(tempBlockNode == NULL)
    
57.          {
    
58.                    perror("allocate memory error!\n");
    
59.                    exit(1);
    
60.          }
    
61.         
    
62.          if(memBlockNodeHead == NULL)
    
63.          {
    
64.                   memBlockNodeHead = tempBlockNode;
    
65.                   memBlockNodeHead->next = NULL;
    
66.          }
    
67.          else
    
68.          {
    
69.                   tempBlockNode->next = memBlockNodeHead;
    
70.                   memBlockNodeHead = tempBlockNode;
    
71.          }
    
72.         
    
73.          freeItemNodeHead = &(memBlockNodeHead->data[0]);
    
74.         
    
75.          int i = 0;
    
76.          while(i < blockSize/itemSize -1)
    
77.          {
    
78.                   tempBlockNode->data[i].next = &(tempBlockNode->data[i+1]);
    
79.                   ++i;
    
80.          }
    
81.         
    
82.          tempBlockNode->data[i].next = NULL;
    
83.      }
    
84.     
    
85.      ItemNode *allocItemNode = freeItemNodeHead;
    
86.      freeItemNodeHead = freeItemNodeHead->next;
    
87.     
    
88.      return allocItemNode;
    
89. }
    
90. 
    
91. void MemPool::Free(void* p)
    
92. {
    
93.       ItemNode *tempItemNode = static_cast<ItemNode*>(p);
    
94.       tempItemNode->next = freeItemNodeHead;
    
95.       freeItemNodeHead = tempItemNode;
    
96. }
    
97. 
    
98. int main()
    
99. {
    
100.      MemPool pool;
     
101.      char *p = NULL;
     
102.      
     
103.      clock_t start, finish;
     
104.      
     
105.      double duration;
     
106.      
     
107.      long i = 0;
     
108.      
     
109.      start = clock();
     
110.      
     
111.      while(i < 10000000)
     
112.      {
     
113.              p = static_cast<char*>(pool.Alloc());
     
114.              //p = new char[16];
     
115.              ++i;
     
116.              pool.Free(p);
     
117.              //delete p;
     
118.     }
     
119.     
     
120.     finish = clock();
     
121.     
     
122.     duration = (double)(finish - start)/CLOCKS_PER_SEC;
     
123.     
     
124.     cout << "total use " << duration << " seconds" << endl;
     
125.     
     
126.     system("pause");
     
127.     
     
128.     return 0;
     
129. }

 

使用内存池的结果是：

total use 0.245 seconds

使用new，delete操作的结果是：

total use 7.256 seconds

 

结果相差近30倍，可见使用内存池对系统的性能有很大的提高

 

MemPool实现源码参见：http://blog.csdn.net/zhangzhenghe/article/details/5437487