c++ 实现内存池

转载于：/article/2269249.html

打开浏览器，搜索了下内存管理的概念，百度百科中是这样定义的：内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。说到内存，与之紧密相联系的一个概念就是指针。回想起上学那会儿，自己对指针是即喜欢，又害怕。因为学好了指针，就可以学好C，继而学好C++，但面对那些晦涩的概念，和程序运行中一些莫名其妙的指针越界、内存泄露……，不免叫人步步惊心。后来参加工作了，在不断的摸爬滚打中，也逐渐对指针和内存熟悉起来。
在编写网络通信程序时，要用到自己的发送缓冲区或接收缓冲区，其实这些缓冲区，都是一块特定的内存。特别在编写服务端程序时，能否管理好自己的内存，对于程序的灵活，高效，稳定，起到莫大的作用。再看一下内存管理的定义，它说的是在PC上，现实中也有很多程序不在PC上，比如基于Linux系统的嵌入式设备。其内存一般也就几M，几十M的样子。在编写设备通信程序，比如协议栈时，就更应该管理好自己的内存啦！
下边，我参考开源项目POCO C++ Libraries，用C++编写了一个内存池类，也算是对学习和工作的一个总结，同时方便今后使用。代码中使用了线程互斥锁，这个可以在互斥对象锁和临界区锁性能比较（Win32）和Linux平台上用C++实现多线程互斥锁看到。以下代码已在VS2005环境下编译通过。
Lock.h

#pragma once
#ifndef _LOCK_H
#define _LOCK_H

#include <windows.h>

//接口类
class IMyLock
{
public:
virtual ~IMyLock(){}

virtual void Lock() const=0;
virtual void UnLock() const =0;
};
class CMutex :public IMyLock
{
public:
CMutex(void);
~CMutex(void);

void Lock() const;
void UnLock() const ;

private:
HANDLE m_mutex;
};

//锁

class CLock
{
public:
CLock(const IMyLock&);
~CLock();
private:
const IMyLock& m_lock;
};

#endif

Lock.cpp

#include "stdafx.h"
#include "lock.h"

CMutex::CMutex()
{
m_mutex=::CreateMutex(NULL,FALSE,NULL);
}

CMutex::~CMutex()
{
if (m_mutex)
{
::CloseHandle(m_mutex);
}
}

void CMutex::Lock() const
{
DWORD dw=WaitForSingleObject(m_mutex,INFINITE);
}

void CMutex::UnLock() const
{
::ReleaseMutex(m_mutex);
}

CLock::CLock(const IMyLock& m):m_lock(m)
{
m_lock.Lock();
}

CLock::~CLock()
{
m_lock.UnLock();
}

MemPool.h

[cpp] view
plaincopy

#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

[cpp] view
plaincopy

#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));

}

下边是测试代码

[cpp] view
plaincopy

// 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;

}

编译，运行