1.引入内存池的意义
内存池(Memory Pool)是一种内存分配方式，又被称为固定大小区块规划（fixed-size-blocks allocation）。通常我们习惯直接使用new、malloc等API申请分配内存，但是这种方式非常容易产生内存碎片，早晚都会申请内存失败。并且在比较复杂的代码或者继承的屎山中，非常容易出现内存泄漏。
内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是能够使内存分配效率得到提升。
2.内存池的实现原理
我们通过一个内存池类来操作内存池，这个类中的所有成员方法都是操作内存池的函数。在我们设想的内存池中，我们以4k为基准定义，申请空间超过4k的我们额外使用malloc分配一个自定义块，并且使用一个管理自定义块的对象来保存它的地址，以便于在释放空间的时候我们能够找到他。申请空间不超过4k的我们就将我们内存池的标准块中的一部分划分给它来减少malloc的次数，若当前标准块的空间不够，则额外开辟一块4k的空间加入内存池并且给它分配空间。
2.1 内存池实现的主要功能
在此，笔者将简述一下内存池类（Mem_pool）的成员函数及其实现的主要功能：
Mem_pool(size_t size) ：构造函数，创建内存池，并初始化一块自定义大小的空间
~Mem_pool() ：析构函数，销毁内存池，遍历各个标准块与大块，把从堆区分配的内存释放
mp_new(size_t size) ：给用户提供的申请内存空间的接口
mp_new_zero(size_t size) ：给用户提供的申请内存空间的接口，并全部初始化为0
mp_delete(void *p) ：给用户提供的释放已申请的内存空间的接口
mp_reset_pool() ：给用户提供的清空内存池中数据的接口
mp_monitor(string msg) ：给用户提供的显示当前内存池使用情况的接口
mp_new_block(size_t size) ：向堆空间申请一块标准块空间
mp_new_large(size_t size) ：向堆空间申请一块长度大于标准块长度的自定义大块空间
2.2 内存池空间分配的实现原理
在管理内存池的类（Mem_pool）中，存在着两个链表，其中一个是以管理标准块的类为数据域的不带表头结点的单链表，另一个是以管理自定义块的类为数据域的不带表头的单链表。
一个管理标准快的对象（Mem_node）管理一个标准块，且该对象的起始地址为该标准块的起始地址。Mem_node类有一个起始指针，一个结束指针与一个next指针，起始指针指向的是该标准块能够分配内存的起始地址，结束指针指向该标准块的结束地址，next指针用来指向下一个Mem_node对象用来形成链表。
一个管理自定义块的对象（Mem_large)管理一个自定义块，每当我们创建一个自定义块的时候我们才创建一个Mem_large对象来管理它，并且该对象在内存池的标准块中申请空间（换句话说就是Mem_large对象的内存空间由内存池的标准快分配）。Mem_large类有一个指向自定义块的指针，用来以后释放空间，还有一个next指针用来形成链表。
每当我们需要申请一块空间的时候，我们首先需要判断这块空间的大小是否大于一个标准块的大小（4k),若没有超过我们就将在标准块中分配这段空间。
假设现在我们在标准块中分配，我们还需要判断我们当前的标准块剩余的可用空间能否容纳下我们需要分配的空间。若可以，我们就将在当前的标准块中划分出空间来实现空间分配，并且减少当前标准块可以分配的空间，如图1所示。若不可以，我们将开辟出一块新的标准块，并实现上述操作，如图2所示。
图1 标准块剩余空间足够的情况
图2 标准块剩余空间不足需要开辟新的标准块的情况
假设我们需要分配的空间超过了4k，我们就需要开辟出一个能够容纳该空间的自定义块，将自定义块的内存空间分配出去，接着我们还需要创建一个管理自定义块的对象，这个对象的一个成员指针保存这段被分配的空间的地址用来便于以后释放，如图3所示。
图3 创建自定义块的情况
随着标准块的创建，我们也将创建一个管理该标准块的对象（Mem_node），并将其挂载在管理内存池的对象（Mem_pool）的链表中，所以我们只需要找到内存池就可以找到所有在内存池中分配的标准块。
随着自定义块的创建，该管理该自定义块的对象将被挂载在管理内存池的对象（Mem_pool）的链表中，所以我们只需要找到内存池就可以找到所有在内存池中分配的自定义块。
2.3 内存池空间释放的实现原理
当我们想要释放一段从内存池中申请的内存空间时，我们需要判断这段空间是存在在标准块中还是自定义块中。
若存在于自定义块中，我们将遍历内存池对象中的管理自定义块对象的链表，找到对应的Mem_large对象后，我们只需要释放该对象中指向自定义块的指针就可以实现自定义块空间的释放了。
若存在于标准块中，我们也需要遍历内存池对象中管理标准块对象的链表，找到对应的Mem_node对象后，我们需要将该对象的引用计数（m_quote)减一（这样的话就可以当作该内存空间已经被释放掉了）。此处需要补充一下，在我们在标准块中申请空间成功时，我们将在增加管理该块的对象中的引用计数，所以该对象的引用计数就是我们在该标准块中申请的内存空间个数。当该块的引用计数为0的时候，我们就可以把这个标准块当作一个刚刚创建的标准块来给其他申请空间的指针来分配空间了。
提醒：内存池的释放仅进行内存空间的释放，为了避免错误操作内存导致程序错误的情况，请一定记得在释放完空间之后将指针置为nullptr。
3、 对new与delete的重载
在C++中我们可以对new与delete进行重载实现对堆空间内存申请操作的接管。 这样的话我们就可以几乎感觉不到任何区别地来使用内存池来申请与释放内存空间了。需要另外提示的一点是我们在对new重载之后，依然可以在new后面对类类型进行初始化从而进入到类的构造函数中，例如：Test * p = new Test(10);
void *operator new(size_t size) { return mp.mp_new(size); } void operator delete(void *p) { mp.mp_delete(p); }
4. C++内存池对纯C内存池的增强
在C++内存池中，我们将内存池封装成了一个对象，通过这个对象来操作内存池，通过提供成员函数接口的操作隐藏了具体的实现代码，可以更加安全与简洁地操作内存池。
另外，将内存池封装成类还可以遵循RAII原则，我们在内存池对象的构造函数里面对内存池进行初始化，在内存池的析构函数里面销毁内存池并且将内存池从内存中申请的所有空间释放，避免了内存泄漏的情况发生。
5、测试如下
class Test { public: Test() = delete; Test(int a, double b, string c); private: int m_a; double m_b; string m_c; }; Test::Test(int a, double b, string c) : m_a(a), m_b(b), m_c(c) { cout << "Test构造！\n"; } int main() { char * p = nullptr; string s1 = "show"; mp.mp_monitor(s1); for(int i =0 ;i <100;i++) { p = (char *)mp.mp_new(50); } mp.mp_monitor(s1); for(int i =0 ;i <20;i++) { p = (char *)mp.mp_new(60); } mp.mp_monitor(s1); p = (char *)mp.mp_new(5000); mp.mp_monitor(s1); mp.mp_delete(p); mp.mp_monitor(s1); Test * p1 = new Test(1,2.0,s1); mp.mp_monitor(s1); return 0; }
6、源码
1 #include <iostream> 2 #include <stdlib.h> 3 #include <string.h> 4 #include <string> 5 6 #define PAGE_SIZE 4096 7 8 using uchar = unsigned char; 9 using namespace std; 10 11 //对齐规则 12 #define MP_ALIGNMENT 16 13 #define mp_align(n, alignment) (((n) + (alignment - 1)) & ~(alignment - 1)) 14 #define mp_align_ptr(p, alignment) (void *)((((size_t)p) + (alignment - 1)) & ~(alignment - 1)) 15 16 17 class Mem_node 18 { 19 public: 20 //初始化node结点 21 void init(); 22 //将node结点置回初始状态 23 void node_clean(); 24 //分配成功，引用计数+1，移动start指针 25 void node_malloc(size_t size); 26 //减少引用计数，若为0移动start指针 27 void node_free(); 28 uchar * get_start(); 29 uchar * get_end(); 30 int get_quote(); 31 //获取end - start的值，也就是当前块现在的可用长度 32 size_t get_len(); 33 Mem_node *get_next(); 34 //每次调用get方法failed计数器自增1 35 int get_failed(); 36 void set_next(Mem_node* next); 37 38 private: 39 uchar *m_start; //标记当前标准块可以使用的起始地址 40 uchar *m_end; //标记当前标准块可以使用的末尾地址 41 Mem_node *m_next; //标准快链表的next指针 42 int m_quote; //当前标准块的引用计数器，用来判断当前标准块是否被使用 43 int m_failed; //当前标准块的错误计数器，用来移动内存池的current指针提高效率 44 }; 45 46 47 class Mem_large 48 { 49 public: 50 //使large结点的成员变量重置为参数所示的值 51 void large_reset(int size,void * alloc); 52 //释放掉large结点指向的自定义块内存空间 53 void large_free(); 54 void set_next(Mem_large * next); 55 Mem_large * get_next(); 56 void * get_alloc(); 57 int get_size(); 58 private: 59 Mem_large *m_next; //自定义块链表的next指针 60 int m_size; //用来存放自定义块所占用的内存大小 61 void *m_alloc; //用来存放自定义块所在的起始地址 62 }; 63 64 65 class Mem_pool 66 { 67 public: 68 Mem_pool() = delete; 69 70 //构造函数，创建内存池，并初始化一块自定义大小的空间 71 explicit Mem_pool(size_t size); //类型转化构造函数，自定义的大小仅允许是4k的整数倍 72 73 //析构函数，销毁内存池，遍历各个标准块与大块，把从堆区分配的内存释放 74 ~Mem_pool(); 75 76 //给用户提供的申请内存空间的接口 77 void *mp_new(size_t size); 78 79 //给用户提供的申请内存空间的接口，并全部初始化为0 80 void *mp_new_zero(size_t size); 81 82 //给用户提供的释放已申请的内存空间的接口 83 void mp_delete(void *p); 84 85 //给用户提供的清空内存池中数据的接口 86 void mp_reset_pool(); 87 88 //给用户提供的显示当前内存池使用情况的接口 89 void mp_monitor(string msg); 90 91 private: 92 //向堆空间申请一块标准块空间 93 void *mp_new_block(size_t size); 94 95 //向堆空间申请一块长度大于标准块长度的自定义大块空间 96 void *mp_new_large(size_t size); 97 98 Mem_node *m_head; //标准块链表的头指针 99 Mem_node *m_current; //标准块链表当前可能使用的指针（局部性原理） 100 Mem_large *m_large; //大块链表的头指针 101 }; 102 103 Mem_pool mp(4096); 104 105 void *operator new(size_t size) 106 { 107 return mp.mp_new(size); 108 } 109 110 void operator delete(void *p) 111 { 112 mp.mp_delete(p); 113 } 114 115 116 117 118 void Mem_node::init() 119 { 120 m_start = (uchar *)this + sizeof(Mem_node); 121 m_end = (uchar *)this + PAGE_SIZE; 122 m_next = nullptr; 123 m_failed = 0; 124 m_quote = 0; 125 } 126 127 //将node结点置回初始状态 128 void Mem_node::node_clean() 129 { 130 m_start = (uchar *)this + sizeof(Mem_node); 131 m_failed = 0; 132 m_quote = 0; 133 } 134 135 //分配成功，引用计数+1，移动start指针 136 void Mem_node::node_malloc(size_t size) 137 { 138 m_quote++; 139 m_start += size; 140 } 141 142 //减少引用计数，若为0移动start指针 143 void Mem_node::node_free() 144 { 145 m_quote--; 146 } 147 148 uchar *Mem_node::get_start() 149 { 150 return m_start; 151 } 152 153 uchar *Mem_node::get_end() 154 { 155 return m_end; 156 } 157 158 int Mem_node::get_quote() 159 { 160 return m_quote; 161 } 162 163 //获取end - start的值，也就是当前块现在的可用长度 164 size_t Mem_node::get_len() 165 { 166 return (m_end - m_start); 167 } 168 169 Mem_node *Mem_node::get_next() 170 { 171 return m_next; 172 } 173 174 //每次调用get方法failed计数器自增1 175 int Mem_node::get_failed() 176 { 177 m_failed++; 178 return m_failed; 179 } 180 181 void Mem_node::set_next(Mem_node *next) 182 { 183 m_next = next; 184 } 185 186 void Mem_large::large_reset(int size, void *alloc) 187 { 188 m_size = size; 189 m_alloc = alloc; 190 } 191 192 void Mem_large::large_free() 193 { 194 free(m_alloc); 195 m_size = 0; 196 m_alloc = nullptr; 197 } 198 199 void Mem_large::set_next(Mem_large *next) 200 { 201 m_next = next; 202 } 203 204 Mem_large *Mem_large::get_next() 205 { 206 return m_next; 207 } 208 209 void *Mem_large::get_alloc() 210 { 211 return m_alloc; 212 } 213 214 int Mem_large::get_size() 215 { 216 return m_size; 217 } 218 219 //构造函数，创建内存池，并初始化一块自定义大小的空间 220 Mem_pool::Mem_pool(size_t size) 221 { 222 if (size < PAGE_SIZE || size % PAGE_SIZE != 0) 223 { 224 size = PAGE_SIZE; 225 } 226 //posix_memalign((void **)&pool, MP_ALIGNMENT, size); 227 //m_current = (Mem_node *)malloc(size); 228 posix_memalign((void **)&m_current, MP_ALIGNMENT, size); 229 m_head = m_current; 230 m_head->init(); 231 m_large = nullptr; 232 } 233 234 //析构函数，销毁内存池，遍历各个标准块与大块，把从堆区分配的内存释放 235 Mem_pool::~Mem_pool() 236 { 237 Mem_large *large = m_large; 238 Mem_node *cur, *next; 239 240 for (large; large != nullptr; large = large->get_next()) 241 { 242 if (large->get_alloc() != nullptr) 243 { 244 free(large->get_alloc()); 245 } 246 } 247 248 cur = m_head; 249 while (cur != nullptr) 250 { 251 next = cur->get_next(); 252 free(cur); 253 cur = next; 254 } 255 } 256 257 //给用户提供的申请内存空间的接口 258 void *Mem_pool::mp_new(size_t size) 259 { 260 if (size <= 0) 261 { 262 return nullptr; 263 } 264 else if (size >= PAGE_SIZE - sizeof(Mem_node)) 265 { 266 return mp_new_large(size); 267 } 268 else 269 { 270 uchar *addr = nullptr; 271 Mem_node *cur = m_current; 272 273 while (cur != nullptr) 274 { 275 if (cur->get_len() >= size) 276 { 277 addr = cur->get_start(); 278 cur->node_malloc(size); 279 return addr; 280 } 281 else 282 { 283 cur = cur->get_next(); 284 } 285 } 286 return mp_new_block(size); 287 } 288 } 289 290 //给用户提供的申请内存空间的接口，并全部初始化为0 291 void *Mem_pool::mp_new_zero(size_t size) 292 { 293 void *mem_addr = mp_new(size); 294 if (mem_addr != nullptr) 295 { 296 memset(mem_addr, 0, size); 297 } 298 return mem_addr; 299 } 300 301 //给用户提供的释放已申请的内存空间的接口 302 void Mem_pool::mp_delete(void *p) 303 { 304 Mem_large *large = m_large; 305 Mem_node *node = nullptr; 306 307 //若需要删除的是自定义块 308 for (large; large != nullptr; large = large->get_next()) 309 { 310 if (p == large->get_alloc()) 311 { 312 large->large_free(); 313 return; 314 } 315 } 316 317 //若要删除的是标准块 318 node = m_head; 319 for (node; node != nullptr; node = node->get_next()) 320 { 321 if (((uchar *)node <= (uchar *)p) && ((uchar *)p <= (uchar *)node->get_end())) 322 { 323 node->node_free(); 324 if (node->get_quote() == 0) 325 { 326 m_current = m_head; 327 } 328 return; 329 } 330 } 331 } 332 333 //给用户提供的清空内存池中数据的接口 334 void Mem_pool::mp_reset_pool() 335 { 336 Mem_node *node = nullptr; 337 Mem_large *large = nullptr; 338 339 for (large = m_large; large != nullptr; large = large->get_next()) 340 { 341 if (large->get_alloc() != nullptr) 342 { 343 free(large->get_alloc()); 344 } 345 } 346 347 for (node = m_head; node != nullptr; node = node->get_next()) 348 { 349 node->node_clean(); 350 } 351 m_current = m_head; 352 } 353 354 //给用户提供的显示当前内存池使用情况的接口 355 void Mem_pool::mp_monitor(string msg) 356 { 357 Mem_node *head = nullptr; 358 Mem_large *large = nullptr; 359 int i = 0; 360 361 printf("\r\n\r\n------start monitor poll------%s\r\n\r\n", msg.c_str()); 362 for (head = m_head; head != nullptr; head = head->get_next()) 363 { 364 i++; 365 if (m_current == head) 366 { 367 cout << "current==>第" << i << "块\n"; 368 } 369 370 printf("第%02d块small block 已使用:%4ld 剩余空间:%4ld 引用:%4d failed:%4d\n", i, 371 head->get_start() - (uchar *)head, 372 head->get_len(), head->get_quote(), head->get_failed()); 373 } 374 375 i = 0; 376 for (large = m_large; large != nullptr; large = large->get_next()) 377 { 378 i++; 379 if (large->get_alloc() != nullptr) 380 { 381 cout << "第" << i << "块large block size=" << large->get_size() << "\n"; 382 } 383 } 384 printf("\r\n\r\n------stop monitor poll------\r\n\r\n"); 385 } 386 387 //向堆空间申请一块标准块空间 388 void *Mem_pool::mp_new_block(size_t size) 389 { 390 int ret; 391 uchar *block = nullptr; 392 uchar *addr = nullptr; 393 Mem_node *node = nullptr; 394 Mem_node *current = m_current; 395 Mem_node *cur = nullptr; 396 397 //int ret = posix_memalign((void **)&block, MP_ALIGNMENT, PAGE_SIZE); 398 //block = (uchar *)malloc(PAGE_SIZE); 399 ret = posix_memalign((void **)&block, MP_ALIGNMENT, PAGE_SIZE); 400 if (ret != 0) 401 { 402 cout << "malloc error" << endl; 403 return nullptr; 404 } 405 406 node = (Mem_node *)block; 407 node->init(); 408 409 addr = (uchar *)mp_align_ptr(block + sizeof(Mem_node), MP_ALIGNMENT); 410 node->node_malloc(size); 411 412 for (cur = current; cur->get_next() != nullptr; cur = cur->get_next()) 413 { 414 if (cur->get_failed() > 4) 415 { 416 current = cur; 417 } 418 } 419 420 cur->set_next(node); 421 m_current = current; 422 return addr; 423 } 424 425 //向堆空间申请一块长度大于标准块长度的自定义大块空间 426 void *Mem_pool::mp_new_large(size_t size) 427 { 428 uchar *big_addr = nullptr; 429 Mem_large *large = nullptr; 430 int ret; 431 int n = 0; 432 433 ret = posix_memalign((void **)&big_addr, MP_ALIGNMENT, size); 434 if (ret) 435 { 436 return nullptr; 437 } 438 439 large = m_large; 440 for (large; large != nullptr; large = large->get_next()) 441 { 442 if (large->get_alloc() == nullptr) 443 { 444 large->large_reset(size, big_addr); 445 return big_addr; 446 } 447 if (n++ > 3) //防止过多次的遍历，限制次数 448 { 449 break; 450 } 451 } 452 453 large = (Mem_large *)mp_new(sizeof(Mem_large)); 454 455 if (large == nullptr) 456 { 457 free(big_addr); 458 return nullptr; 459 } 460 461 large->large_reset(size, big_addr); 462 //头插法 463 large->set_next(m_large); 464 m_large = large; 465 466 return big_addr;