一个简单实用的内存池之一（c实现)

http://www.cppblog.com/jaxe/archive/2009/09/17/96581.html

都知道频繁分配内存释放内存很耗系统资源，而且容易造成内存碎片。因此写了个简单的内存池实现，越简单越好，为什么？做复杂了效率还不如直接malloc。因此这个内存池采用链表连接内存块的方式，分配的是固定大小的内存块，从池中取内存和归还内存是用的空闲链表堆栈操作， 没有使用线程锁，如果要线程安全，建议在外部调用内存池的地方加锁。

做过一个简单的测试，10万次内存池调用的效率大概比直接分配释放内存提高了30-50%。但是前提是内存池不能加锁（pthread_mutex），加锁的内存池效率和直接分配内存的效率差不多，有时候还要多点点。（测试的环境是每次2K，4个双核CPU，FREEBSD7）

代码实现：


struct memblock






{


int used;


void* data;


struct memblock* next;


struct memblock* createnext;


};

struct mempool

{

int size;//memblock大小

int unused;//空闲的memblock大小

int datasize;//每次分配的数据大小(就是memblock.data)

struct memblock* free_linkhead;//空闲memblock链表头

struct memblock* create_linkhead;//所有创建的memblock链表头，内存池释放的时候使用，防止内存池释放的似乎还有memblock未归还的情况

};

typedef void (*free_callback)(void*);//释放回调函数，释放membloc.data用，可以简单的直接用free函数

void mempool_init(int initialSize,int datasize);//初始化mempool

void mempool_dealloc(struct mempool* pool,free_callback callback);//释放mempool

void* mempool_get(struct mempool* pool);//获取一个memblock

void mempool_release(struct mempool* pool,struct memblock* block);//归还一个memblock

/*********************************

* mempool

* ******************************/

//malloc一个memblock

static struct memblock* mempool_allocblock( struct mempool* pool );

//------------------implement--------

void*

mempool_init( int initialSize, int datasize )

{

struct mempool* pool = malloc( sizeof( struct mempool ) );

pool->unused = 0;

pool->datasize = datasize;

pool->free_linkhead = NULL;

//预先初始化initialSize个内存块

pool->create_linkhead = NULL;

int i;

for ( i = 0; i < initialSize; i++ ) {

struct memblock* block = mempool_allocblock( pool );

mempool_release( pool, block );

}

return ( pool );

}

void

mempool_dealloc( struct mempool* pool, free_callback callback )

{

struct memblock* block = NULL;

//将所有创建的memblock释放了

while ( pool->create_linkhead != NULL ) {

block = pool->create_linkhead;

pool->create_linkhead = pool->create_linkhead->createnext;

//执行free回调。

if ( callback ) {

( *callback )( block->data );

}

free( block );

}

free( pool );

L_DEBUG( "%s:size(%d),unused(%d)", __func__, pool->size, pool->unused );

}

static struct memblock*

mempool_allocblock( struct mempool* pool )

{

struct memblock* block = malloc( sizeof( struct memblock ) );

block->data = malloc( sizeof( pool->datasize ) );

block->next = NULL;

block->used = 1;//表示已使用

//加入所有创建的memblock的链表头

block->createnext = pool->create_linkhead;

pool->create_linkhead = block;

pool->size++;

return ( block );

}

void

mempool_release( struct mempool* pool, struct memblock* block )

{

if ( block == NULL ) {

L_WARN( "%s:release a NULL!", __func__ );

return;

}

if ( block->used != 1 ) {

L_WARN( "%s:used!=1", __func__ );

return;

}

//将归还的内存块放到空闲链表头。

block->used = 0;//表示空闲

block->next = pool->free_linkhead;

pool->free_linkhead = block;

pool->unused++;//空闲数+1

}

void*

mempool_get( struct mempool* pool )

{

struct memblock* block = NULL;

if ( pool->free_linkhead ) {

//从空闲链表头取出一个内存块

block = pool->free_linkhead;

pool->free_linkhead = pool->free_linkhead->next;

block->next = NULL;

block->used = 1;//表示已使用

pool->unused--;//空闲内存块数-1

}

else {

//没有空闲的内存块，创建一个

block = mempool_allocblock( pool );

}

return ( block );

}