記憶體池簡單執行個體

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

使用記憶體池的結果是： total use 0.245 seconds 使用new，delete操作的結果是： total use 7.256 seconds   結果相差近30倍，可見使用記憶體池對系統的性能有很大的提高  

MemPool實作源碼參見：http://blog.csdn.net/zhangzhenghe/article/details/5437487