操作方法：固定内存池（包括代码）的实现

所谓的内存池是指应用程序可以通过系统的内存分配调用一次申请适当大小的内存作为内存池，然后，内存分配和应用程序本身的释放就可以通过此内存池完成。 。仅当需要动态扩展内存池的大小时，才需要再次调用系统的内存分配功能，并且其他时候对内存的所有操作都在应用程序的控制之下。

根据不同的适用方案，应用程序定义的内存池具有不同的类型。

从线程安全的角度来看，内存池可以分为单线程内存池和多线程内存池。单线程内存池在其整个生命周期中仅由一个线程使用，因此无需考虑互斥访问的问题。多线程内存池可能由多个线程共享，因此每次分配和释放内存时都必须锁定。相比之下，单线程内存池具有更高的性能，而多线程内存池具有更广泛的应用程序。

从存储池可以分为存储单元的大小，可以分为固定存储池和可变存储池。所谓的固定存储池，是指应用程序每次从存储池中分配的存储单元的大小已经预先确定并固定；而可变内存池则可以根据需要更改每次分配的内存单元的大小，应用范围更广，性能也低于固定内存池。

具体的介绍可以在这篇IBM文章中找到：

前一段时间，我有一些空闲时间，所以我写了一个基本的内存池实现。它不支持多线程，并且是固定的内存池。

如果您想参考这篇文章，可以在这里查看我的代码。

ps：非常感谢Xiao Lai帮助我调试了内存恢复错误。有时编写一段代码只需要1到2个小时，但是发现bug可能需要1天。

memory_pool.h

#ifndef MEMORY_POOL_H     
#define MEMORY_POOL_H     
    
/***********************************  
* author:hairetzhang                *  
* date:2009.9.1                     *  
* funtion: regular memory pool lib  *  
* version 1.0                       *  
*                                   *  
************************************/ 
    
#include      
#include      
    
using namespace std;     
    
#define  USHORT unsigned short     
#define  ULONG  unsigned long     
#define ADATAUNIT  2     
#define MEMPOOL_ALIGNMENT 4       //机器的字节对齐数     
    
    
    
struct MemoryBlock     
{     
    MemoryBlock*  pNext;     
    USHORT          nSize;        //每个block的总小块数     
    USHORT          nfree_left;   //剩余小块的数目     
    USHORT          nfirst_index; //第一个可用小块的索引号      
    USHORT            aData[1];   //第一个小块前一个字节，不被使用     
    
         
        //nSize = nTypes;   //记录分配的小块数     
        //pNext = NULL;     
    static void* block_new( USHORT nTypes, USHORT nUnitSize)     
    {     
        MemoryBlock*  my_block;     
        my_block = (MemoryBlock *) malloc(sizeof(MemoryBlock) + nTypes * nUnitSize);     
        cout << "sizeof block is :" << sizeof(MemoryBlock) <
        my_block->nSize = nTypes;    //申请时，块内初始化     
        my_block->nfree_left = nTypes;     
        my_block->nfirst_index = 0;     
        my_block->pNext = NULL;     
        return my_block;     
    
    }     
    static void  block_delete(void *p )     
    {     
        free(p);     
    }     
    MemoryBlock (USHORT nTypes = 1, USHORT nUnitSize = 0);     
    ~MemoryBlock();     
};     
    
    
class MemoryPool     
{     
private:     
    MemoryBlock*   pBlock;     
    USHORT          nUnitSize;     
    USHORT          nInitSize;     
    USHORT          nGrowSize;     
    
public:     
                     MemoryPool( USHORT nUnitSize,     
                                  USHORT nInitSize = 1024,     
                                  USHORT nGrowSize = 256 );     
                    ~MemoryPool();     
    
    void*           Alloc();     
    void            Free( void* p );                                  
    void            init_block(MemoryBlock* new_block , USHORT nSize);     
    void*           get_pblock();  //用于调试     
};  
#endif   

memory_pool.cpp

#include "stdafx.h"  
#include   
#include   
#include "memory_pool.h"  
 
using namespace std;  
 
MemoryPool::MemoryPool( USHORT _nUnitSize,  
              USHORT _nInitSize, USHORT _nGrowSize )  
{  
    pBlock      = NULL;                 
    nInitSize   = _nInitSize;  //每个块分配的索引小块数     
    nGrowSize   = _nGrowSize;  //增长块的内存索引小块数     
    
    //设置小块的大小     
    if ( _nUnitSize > 4 )                         
        nUnitSize = (_nUnitSize + (MEMPOOL_ALIGNMENT-1)) & ~(MEMPOOL_ALIGNMENT-1);      
    else if ( _nUnitSize <= 2 )     
        nUnitSize = 2;                   
    else    
        nUnitSize = 4;     
}     
    
    
//初始化分配的新块,nSize为该块的总索引数
void   MemoryPool::init_block( MemoryBlock* new_block ,USHORT nSize )      
{//从第二个小块开始设置索引，第一个小块返回提供使用
    char *pdata = (char * )new_block->aData;      
    USHORT *mini_block_head;     
    for(int i = 1 ;i < nSize; ++i)         
    { //设置每个小块的索引头,0号返回给该次申请者使用
        mini_block_head = (USHORT *)(pdata+nUnitSize*i +ADATAUNIT);     
        *mini_block_head = i+1;     
    }     
    new_block->nfirst_index = 1;     
    new_block->nfree_left = nSize-1;     
}     
    
void* MemoryPool::Alloc()     
{     
    if( !pBlock )  //当前内存池尚无内存块，第一次分配     
    {     
        pBlock = (MemoryBlock *) MemoryBlock::block_new (nInitSize, nUnitSize);
        init_block( pBlock ,nInitSize);     
        return (void *) (pBlock->aData+1);     
    }
    
    MemoryBlock* pMyBlock = pBlock; //从链表头部pBlock开始
    while (pMyBlock && !pMyBlock->nfree_left ) //搜索可用内存快
        pMyBlock = pMyBlock->pNext;
 
    if ( pMyBlock )  //尚有可用的内存快     
    {
        char* pFree = (char *) ( (ULONG)pMyBlock->aData+
          ( pMyBlock->nfirst_index*nUnitSize)+ADATAUNIT );
        printf("pMyBlock->aData:%p, pFree:%p\n",pMyBlock->aData,pFree);
        pMyBlock->nfirst_index = *( (USHORT *)pFree );//每小块的头部两字节记录了下一个可用索引号
        pMyBlock->nfree_left--;
        return (void*)pFree;
    }
    else    //找不到可用内存块     
    {     
        if ( !nGrowSize )     
            return NULL;     
        pMyBlock = (MemoryBlock *)MemoryBlock::block_new (nGrowSize, nUnitSize);
        if ( !pMyBlock )     
            return NULL;     
    
        pMyBlock->pNext = pBlock; //新块插入到块链表头部
        pBlock = pMyBlock;     
    
        init_block( pMyBlock ,nGrowSize);     
    
        return (void*)(pMyBlock->aData+ADATAUNIT);     
    }     
}     
    
    
void MemoryPool::Free( void* pFree )     
{     
    USHORT* pfree_us;        
    USHORT pfree_index, pHead;     
    pfree_us = (USHORT *)pFree;     
    MemoryBlock* pMyBlock = pBlock;     
    MemoryBlock* pre_pBlock = NULL;     
    
    while ( ((ULONG)pMyBlock->aData > (ULONG)pfree_us) ||
         ((ULONG)pfree_us >= 
         ((ULONG)pMyBlock->aData + pMyBlock->nSize*nUnitSize)))
       //定位pFree所在的块     
    {     
         pre_pBlock = pMyBlock;     
         pMyBlock = pMyBlock->pNext;     
    }     
    if(pMyBlock == NULL) //pFree不是属于内存池管理的内存
        return;
    
    //回收pFree
    pMyBlock->nfree_left++;
    pHead = pMyBlock->nfirst_index;  //第一个可用索引
    pfree_index = ( (ULONG)pfree_us-(ULONG)pMyBlock->aData -ADATAUNIT)/nUnitSize;
//获取pFree的索引号     
    pMyBlock->nfirst_index = pfree_index;  //pFree插入到可用块首
    *pfree_us = pHead;  //之前的块首链入
          
    //判断是否需要将Block内存返回给系统
     if (pMyBlock->nfree_left  == pMyBlock->nSize )                           
    {     
        if(pre_pBlock)   //删除的不是第一个MemoryBlock
            pre_pBlock->pNext = pMyBlock->pNext;
        pBlock = pMyBlock->pNext;//删除的是第一个MemoryBlock
        MemoryBlock::block_delete(pMyBlock);     
    }     
    
}     
    
MemoryPool::~MemoryPool()     //析构函数释放所有的MemoryBlock，即使用户忘记free掉自己申请的内存也不会发生内存泄漏     
{     
    MemoryBlock*   my_block = pBlock;     
    MemoryBlock*   next_block = NULL;     
    while( my_block )     
    {     
        next_block = my_block->pNext;     
        MemoryBlock::block_delete( (void *)my_block);     
        my_block = next_block;     
    }     
}     
    
void* MemoryPool::get_pblock()     
{     
    return pBlock;     
} 

（hairetz）

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/shoujiruanjian/article-322404-1.html