简单的对象池实现

一个简单的对象池的实现

一个简单的对象池的实现，预分配，加锁，线程安全

#ifndef ___OBJECT_POOL_
#define ___OBJECT_POOL_
#include 
#include 
#include 
#include 
#include 

template< class T >
class ObjectPool
{
public:
	ObjectPool(size_t ChunkSize = 32);
	virtual ~ObjectPool();
	void SetChunkSize(size_t ChunkSize);
	T* New();
	void Delete(T *pT);
private:
	void AllocateChunk(size_t ChunkSize);
	void ReleaseChunk();
private:
	std::queue< T* > free_pool;
	std::vector< T* > chunk_pool;
	size_t chunk_size;
	std::mutex pool_lock;
};

template< class T >
ObjectPool< T >::ObjectPool(size_t ChunkSize)
	:chunk_size(ChunkSize)
{}

template< class T >
ObjectPool< T >::~ObjectPool()
{
	ReleaseChunk();
}

template< class T >
void ObjectPool< T >::SetChunkSize(size_t ChunkSize)
{
	if (0 == ChunkSize)
	{
		assert(false);
		return;
	}
	chunk_size = ChunkSize;
	if (free_pool.empty())
	{
		return;
	}
	if (free_pool.size() < chunk_size)
	{
		std::unique_lock<std::mutex> lock(pool_lock);
		AllocateChunk(chunk_size - free_pool.size());
	}
}

template< typename T >
T* ObjectPool< T >::New()
{
	{
		std::unique_lock<std::mutex> lock(pool_lock);
		if (free_pool.empty())
		{
			AllocateChunk(chunk_size);
		}
		if (free_pool.empty())
		{
			assert(false);
			return nullptr;
		}
		T* pT = free_pool.front();
		free_pool.pop();
	}
	new(pT)T();
	return pT;
}

template< typename T >
void ObjectPool< T >::Delete(T *pT)
{
	if (nullptr == pT)
	{
		assert(false);
		return;
	}
	pT->~T();
	std::unique_lock<std::mutex> lock(pool_lock);
	free_pool.push(pT);
}

template< typename T >
void ObjectPool< T >::AllocateChunk(size_t ChunkSize)
{
	if (0 == ChunkSize)
	{
		assert(false);
		return;
	}
	T* pT = reinterpret_cast<T*>(malloc(ChunkSize * sizeof(T)));
	if (nullptr == pT)
	{
		assert(false);
		return;
	}

	for (size_t i = 0; i < ChunkSize; ++i)
	{
		free_pool.push(pT + i);
	}
	chunk_pool.push_back(pT);
}

template< typename T >
void ObjectPool< T >::ReleaseChunk()
{
	std::unique_lock<std::mutex> lock(pool_lock);
	for (size_t i = 0; i < chunk_pool.size(); ++i)
	{
		free(chunk_pool[i]);
		chunk_pool[i] = nullptr;
	}
	chunk_pool.clear();
}
#endif