用C++实现自己的内存池

Dear 丶 2022-04-11 06:01 181阅读 0赞

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

#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

\[b\]MemPool.cpp\[/b\]

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

\[b\]下边是测试代码\[/b\]

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

\[b\]编译，运行\[/b\]  
\[align=center\]\[img\]http://hi.csdn.net/attachment/201112/14/0\_1323869108dD16.gif\[/img\]\[/align\]