C++内存池的概念及其实现

    内存池(Memory Pool)是一种内存分配方式。 通常我们习惯直接使用new、malloc等API申请分配内存，这样做的缺点在于：由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。
    内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是尽量避免了内存碎片，使得内存分配效率得到提升。

    在编写网络通信程序时，要用到自己的发送缓冲区或接收缓冲区，其实这些缓冲区，都是一块特定的内存。特别在编写服务端程序时，能否管理好自己的内存，对于程序的灵活，高效，稳定，起到莫大的作用。再看一下内存管理的定义，它说的是在PC上，现实中也有很多程序不在PC上，比如基于Linux系统的嵌入式设备。其内存一般也就几M，几十M的样子。在编写设备通信程序，比如协议栈时，就更应该管理好自己的内存啦！

下面是内存池的C++实现代码

MemPool.h

empool.h

#ifndef _MEM_POOL_H
#define _MEM_POOL_H

#include <vector>
#include <iostream>
#include "Lock.h"

using namespace std;

/*
	在内存池中分配固定大小的内存块

	该类的目的是加速内存分配速度，并且减少因重复分配相同
	内存时产生的内存碎片，比如在服务器应用程序中。
*/

class CMemPool
{
public:

	//创建大小为blockSize的内存块，内存池数目为预分配的数目preAlloc
	CMemPool(std::size_t blockSize, int preAlloc = 0, int maxAlloc = 0);

	~CMemPool();

	//获取一个内存块。如果内存池中没有足够的内存块，则会自动分配新的内存块
	//如果分配的内存块数目达到了最大值，则会返回一个异常
	void* Get();

	//释放当前内存块，将其插入内存池
	void Release(void* ptr);

	//返回内存块大小
	std::size_t BlockSize() const;

	//返回内存池中内存块数目
	int Allocated() const;

	//返回内存池中可用的内存块数目
	int Available() const;

private:
	CMemPool();
	CMemPool(const CMemPool&);
	CMemPool& operator = (const CMemPool&);

	enum
	{
		BLOCK_RESERVE = 32
	};

	typedef std::vector<char*> BlockVec;

	std::size_t m_blockSize;
	int         m_maxAlloc;
	int         m_allocated;
	BlockVec    m_blocks;
	CMutex		m_mutex;
};

inline std::size_t CMemPool::BlockSize() const
{
	return m_blockSize;
}


inline int CMemPool::Allocated() const
{
	return m_allocated;
}


inline int CMemPool::Available() const
{
	return (int) m_blocks.size();
}

#endif

MemPool.cpp

#include "MemPool.h"

CMemPool::CMemPool(std::size_t blockSize, int preAlloc, int maxAlloc):
m_blockSize(blockSize),
m_maxAlloc(maxAlloc),
m_allocated(preAlloc)
{
	if ( preAlloc < 0 || maxAlloc == 0 || maxAlloc < preAlloc )
	{
		cout<<"CMemPool::CMemPool parameter error."<<endl;
	}

	int r = BLOCK_RESERVE;
	if (preAlloc > r)
		r = preAlloc;
	if (maxAlloc > 0 && maxAlloc < r)
		r = maxAlloc;
	m_blocks.reserve(r);
	for (int i = 0; i < preAlloc; ++i)
	{
		m_blocks.push_back(new char[m_blockSize]);
	}
}


CMemPool::~CMemPool()
{
	for (BlockVec::iterator it = m_blocks.begin(); it != m_blocks.end(); ++it)
	{
		delete [] *it;
	}
}


void* CMemPool::Get()
{
	CLock lock(m_mutex);

	if (m_blocks.empty())
	{
		if (m_maxAlloc == 0 || m_allocated < m_maxAlloc)
		{
			++m_allocated;
			return new char[m_blockSize];
		}
		else
		{
			cout<<"CMemPool::get CMemPool exhausted."<<endl;
			return (void *)NULL;
		}
	}
	else
	{
		char* ptr = m_blocks.back();
		m_blocks.pop_back();
		return ptr;
	}
}


void CMemPool::Release(void* ptr)
{
	CLock lock(m_mutex);

	m_blocks.push_back(reinterpret_cast<char*>(ptr));
}

下边是测试代码

// CMyMemPool.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "MemPool.h"

#define DATA_BLOCK_LEN 1500

int _tmain(int argc, _TCHAR* argv[])
{
	CMemPool myPool1(DATA_BLOCK_LEN, 0, 10);

	cout<<"myPool1 block size = "<<myPool1.BlockSize()<<endl;
	cout<<"myPool1 allocated block num = "<<myPool1.Allocated()<<endl;
	cout<<"myPool1 available block num = "<<myPool1.Available()<<endl<<endl;

	std::vector<void*> ptrs;
	for (int i = 0; i < 10; ++i)
	{
		ptrs.push_back(myPool1.Get());
	}

	myPool1.Get();

	int iavilable = 0;
	for (std::vector<void*>::iterator it = ptrs.begin(); it != ptrs.end(); ++it)
	{
		myPool1.Release(*it);
		++iavilable;
		cout<<"myPool1 available block num = "<<myPool1.Available()<<endl;
	}

	CMemPool myPool2(DATA_BLOCK_LEN, 5, 10);
	cout<<endl<<"myPool2 block size = "<<myPool2.BlockSize()<<endl;
	cout<<"myPool2 allocated block num = "<<myPool2.Allocated()<<endl;
	cout<<"myPool2 available block num = "<<myPool2.Available()<<endl;

	int iWait;
	cin>>iWait;

	return 0;
}