.h文件

/**********************说明*************************
* 这是MPool内存池的实现，他具有如下特性：
* 1. 池中的内存块是大小是相同的
* 2. 由宏定义_MP_NO_SERIALIZE决定是否需要多线程同步
* 3. 他利用windows的堆内存API进行内存分配
* 4. 他不能替换crt的malloc和free
* 5. 他不是一个通用型的内存池
* 6. 适用于特定的应用环境(高频率的申请释放内存，如网络服务器)，应用环境影响池中内存块的大小，以及是否需要处理多线程同步
*
* 编写这样一个内存池基于这几点原因
* 1. 减少内存碎片(每次分配等长的内存块有利于减少内存碎片，内存块的大小还要考虑内存对齐)
* 2. 提高内存分配效率（非序列化的内存分配可以显著提高效率）
* 3. 网络上很多通用型内存池的做法，本人认为通用型的内存池就应该是操作系统本身的内存管理API,
     在ring3层做通用内存池没有意义，甚至可能起到反效果。这种情况最简单的解决问题的办法是增加物理内存的容量。
     只有针对特定的应用环境编写的内存池才是有意义的。
*/
#ifndef MPOOL_H
#define MPOOL_H

#include <Windows.h>
#include <vector>

using std::vector;


class MPool
{
public:
    MPool(size_t block_size);
    ~MPool();

    void *MPAlloc();
    void MPFree(void *p);
private:
    MPool(const MPool&);
    MPool& operator=(const MPool&);
private:
    RTL_CRITICAL_SECTION *m_pool_lock;
    vector<void*> m_block_list;
    size_t m_block_size;
    size_t m_total_size;
    size_t m_block_count;
    size_t m_reserve_count;
    HANDLE m_heap;
    DWORD m_heap_option;
};

#endif

.cpp文件

#include "mpool.h"

#ifdef _MP_NO_SERIALIZE
#define MPLOCK() 
#define MPUNLOCK() 
#else
#define MP_LOCK() EnterCriticalSection(m_pool_lock);
#define MP_UNLOCK() LeaveCriticalSection(m_pool_lock);
#endif


MPool::MPool( size_t block_size )
{
    m_block_size = block_size;
    size_t m = m_block_size % 8;
    if(m != 0)
    {
        m_block_size += (8-m);
    }    
    _SYSTEM_INFO info;
    memset(&info,0,sizeof(_SYSTEM_INFO));
    GetSystemInfo(&info);
    m_heap_option = 0;
#ifdef _MP_NO_SERIALIZE
    m_heap_option = HEAP_NO_SERIALIZE;
#else
    m_pool_lock = new RTL_CRITICAL_SECTION;    
    InitializeCriticalSectionAndSpinCount(m_pool_lock,4000);
#endif
    m_heap = HeapCreate(m_heap_option,info.dwPageSize,0);    
    m_block_list.reserve(1024);
}

MPool::~MPool()
{
    while(!m_block_list.empty())
    {   
        HeapFree(m_heap,m_heap_option,m_block_list.back());
        m_block_list.pop_back();
    }

#ifndef _MP_NO_SERIALIZE
    DeleteCriticalSection(m_pool_lock);
    delete m_pool_lock;
#endif
}

_inline void * MPool::MPAlloc()
{
    void *ret;
    MP_LOCK();
    if(!m_block_list.empty())
    {
        ret = m_block_list.back();
        m_block_list.pop_back();
    }
    else
    {
        ret = HeapAlloc(m_heap,m_heap_option,m_block_size);        
    }
    MP_UNLOCK();
    return ret;    
}

_inline void MPool::MPFree( void *p )
{
    if(p)
    {    
        MP_LOCK();    
        m_block_list.push_back(p);
        MP_UNLOCK();
    }
}