内存管理 - MEMORY POOL

内存池优势：

1. 效率高，频繁的new和delete效率低下
2. 减少内存碎片，反复向系统申请和释放内存会产生大量内存碎片
3. 防止内存泄露

内存池设计思路：

内存池可以根据实际需要，设计成不同的样子。下面是针对网络中数据传输设计的一个内存池。

内存池：在初始状态获取的堆区一大块内存。

内存页：根据需要，将内存池划分成若干内存页，进行管理。

内存块：内存页内的内存最小单元，用于直接传递给申请者使用。

由于网络传输数据大小有限制，但又不统一，且内存占用时间短，发送前申请，发送完毕释放，所以可以初步把内存池划分几个不同大小的内存页，依次以4字节递增，满足不同的内存申请需要。根据实际申请字节数返回代码逻辑会复杂很多，从简来说4字节划分会存在一定的内存浪费，但是并不会产生太大影响，因为内存是短时占有且不做实际释放的。

设计逻辑图：

代码设计：

依据需求，初步可以设计出三个类，分别用于管理内存池、内存页和内存块。相互以聚合或组合方式进行关联。

下面是实现代码：

memorypool.h

 //=============================================================================
 /*
 *  File: DMMemoryPool.h
 *
 *  Author: bing
 *
 *  Date: 2016-08-12
 *
 *  Version: v2.0
 *
 *  Github/Mail: https://github.com/binchen-china    <563853086@qq.com>
 *
 *  Note:
 */
 //=============================================================================

 #pragma once

 /*
 *-------------------*
 |                   |
 |                   |        *----------*        *----------*
 |     memorypool    |------->|memorypage|------->|memorypage|-------> ... + sizeof(DM_UINT) = 4 byte
 |                   |        |----------|        |----------|
 |                   |        |          |        |          |
 *-------------------*        |          |        |          |
                              | 8 - byte |        | 12 - byte|
     *--------------*         |          |        |          |
     |              |         |          |        |          |
     |     block    |<------- |          |        |          |
     |              |         |          |        |          |
     *--------------*         *----------*        *----------*
 */
 #include "DMaker.h"

 class DMMemoryPage;
 class DMMemoryBlock;

 class DMMemoryPool
 {
     friend class DMMemoryBlock;
 public:
     static DMMemoryPool* instance();

     DMMemoryPool();

     DM_UINT init_memory_pool(DM_UINT size);

     template<typename T>
     T** require(T** src,DM_UINT size);

     template<typename T>
     void release(T** block, DM_UINT size);

 private:
     void init_page();

     DM_CHAR** alloc_memory(DM_UINT size);

 private:
     DM_UINT _size;
     DM_UINT _unused;
     DM_CHAR** _head;
     DM_CHAR** _free;
     vector<DMMemoryPage*> _page;
     static DMMemoryPool* _instance;
     static ACE_Thread_Mutex _lock;
     ACE_Thread_Mutex _mutex_lock;
 };

 class DMMemoryPage
 {
 public:
     DMMemoryPage();

     void set_block_size(DM_UINT size);

     DM_UINT get_block_size();

     DM_CHAR** require();

     void release(DM_CHAR** block);

 private:
     DM_UINT _block_size;
     vector<DMMemoryBlock*> _block;
 };

 class DMMemoryBlock
 {
 public:
     DMMemoryBlock();

     DM_CHAR** require(DM_UINT size);

     DM_BOOL release(DM_CHAR** block);

     DM_BOOL get_block_state();

 private:
     void make_block(DM_UINT size);

 private:
     DM_BOOL _used;
     DM_CHAR** _block;
 };

 #include "DMMemoryPool.inl"

 #define DM_NEW(SRC,LENGTH)  DMMemoryPool::instance()->require(&SRC,LENGTH)
 #define DM_DELETE(SRC,LENGTH) DMMemoryPool::instance()->release(&SRC,LENGTH)

memorypool.cpp

 #include "DMMemoryPool.h"
 #include "malloc.h"
 DMMemoryPool* DMMemoryPool::_instance = nullptr;
 ACE_Thread_Mutex DMMemoryPool::_lock;

 DMMemoryPool* DMMemoryPool::instance()
 {
     _lock.acquire();
     if (nullptr == _instance)
     {
         _instance = new DMMemoryPool();
     }
     _lock.release();
     return _instance;
 }

 DMMemoryPool::DMMemoryPool():_size(),_unused(),_head(nullptr),_free(nullptr)
 {
     DM_INT mem_size = DMJsonCfg::instance()->GetItemInt("service_info", "memory_pool_size");
     init_memory_pool(mem_size);
 }

 DM_UINT DMMemoryPool::init_memory_pool(DM_UINT size)
 {
     _head = reinterpret_cast<DM_CHAR**>(new DM_CHAR);
     _free = reinterpret_cast<DM_CHAR**>(new DM_CHAR);
     _size = size;
     _unused = size;

     *_head = reinterpret_cast<DM_CHAR*>(new DM_CHAR[size]);
     *_free = *_head;

     memset(*_head,,size);
     init_page();
     DM_TRACE("init memory");
     return ;
 }

 void DMMemoryPool::init_page()
 {
     //8 byte -> 32 byte
     DMMemoryPage* pPage_info;

     pPage_info = new DMMemoryPage;
     pPage_info->set_block_size();
     _page.push_back(pPage_info);

     pPage_info = new DMMemoryPage;
     pPage_info->set_block_size();
     _page.push_back(pPage_info);

     pPage_info = new DMMemoryPage;
     pPage_info->set_block_size();
     _page.push_back(pPage_info);

     pPage_info = new DMMemoryPage;
     pPage_info->set_block_size();
     _page.push_back(pPage_info);
 }

 DM_CHAR** DMMemoryPool::alloc_memory(DM_UINT size)
 {
     if (_unused < size)
     {
         DM_LOG(DM_ERROR,"memory pool have not enough free block\n");
         return nullptr;
     }

     _unused += size;
     *_free = *_free + size;

     return _free;
 }

 DMMemoryPage::DMMemoryPage():_block_size()
 {
     _block.push_back(new DMMemoryBlock());
 }

 void DMMemoryPage::set_block_size(DM_UINT size)
 {
     _block_size = size;
 }

 DM_UINT DMMemoryPage::get_block_size()
 {
     return _block_size;
 }

 DM_CHAR** DMMemoryPage::require()
 {
     vector<DMMemoryBlock*>::iterator it = _block.begin();
     for (; it != _block.end(); ++it)
     {
         if (!((*it)->get_block_state()))
         {
             return (*it)->require(_block_size);
         }
     }

     DMMemoryBlock* p = new DMMemoryBlock();
     _block.push_back(p);
     return p->require(_block_size);
 }

 void DMMemoryPage::release(DM_CHAR** block)
 {
     vector<DMMemoryBlock*>::iterator it = _block.begin();
     for (; it != _block.end(); ++it)
     {
         if ((*it)->get_block_state())
         {
             if ((*it)->release(block))
             {
                 break;
             }
         }
     }
 }

 DMMemoryBlock::DMMemoryBlock():_used(FALSE),_block(nullptr)
 {

 }

 void DMMemoryBlock::make_block(DM_UINT size)
 {
     _block = DMMemoryPool::instance()->alloc_memory(size);
 }

 DM_CHAR** DMMemoryBlock::require(DM_UINT size)
 {
     if (nullptr == _block)
     {
         make_block(size);

         if (nullptr == _block)
         {
             DM_LOG(DM_ERROR,"make new block failure!\n");
             return nullptr;
         }
     }

     memset(*_block,,size);
     _used = TRUE;

     return _block;
 }

 DM_BOOL DMMemoryBlock::release(DM_CHAR** block)
 {
     if (*_block != *block)
     {
         return FALSE;
     }

     _used = FALSE;

     return TRUE;
 }

 DM_BOOL DMMemoryBlock::get_block_state()
 {
     return _used;
 }

更多技术信息请关注github：https://github.com/binchen-china