多线程内存池实现

多线程的内存池是基于模板的类：

template <typename POOLTYPE,typename LOCK>
class MTMemoryPool
{
public:
	void* alloc(size_t size);
	void free(void* someElement);
private:
	POOLTYPE stPool;
	LOCK theLock;
};

template <typename M,typename L>
void* MTMemoryPool<M,L>::alloc(size_t size)
{
	void *mem;
	theLock.lock();
	mem=stPool.alloc(size);
	theLock.unlock();
	return mem;
}

template <typename M,typename L>
void MTMemoryPool<M,L>::free(void* doomed)
{
	theLock.lock();
	stPool.free(doomed);
	theLock.unlock();
}

第一个模板参数是指定的适用于单线程的内存池。要求实现alloc和free接口。

第二个参数是采用的锁的类。要求实现lock和unlock接口。

此模板类也可以适用于单线程的情况，只要实现一个锁类，其lock和unlock什么都不做。

使用此线程池的类：

#include "ByteMemoryPool.h"
#include "MutexLock.h"

class Rational
{
public:
	Rational(int a=0,int b=1):n(a),d(b) {}

	void *operator new(size_t size) 
	{
		return memPool->alloc(size);
	}
	void operator delete(void* doomed,size_t size) 
	{
		memPool->free(doomed);
	}

	static void newMemPool() {memPool=new MTMemoryPool<ByteMemoryPool,MutexLock>;}
	static void deleteMemPool() {delete memPool;}
private:
	int n;
	int d;

	static MTMemoryPool<ByteMemoryPool,MutexLock>* memPool;
};

MTMemoryPool<ByteMemoryPool,MutexLock>* Rational::memPool=nullptr;

测试代码同前两篇单线程的情况。
其中MutexLock类的实现如下：

抽象基类：

class ABCLock
{
public:
	virtual ~ABCLock()=0;
	virtual void lock()=0;
	virtual void unlock()=0;
};

MutexLock类：

#include "ABCLock.h"
#include <pthread.h>

class MutexLock:public ABCLock
{
public:
	MutexLock()
	{
		pthread_mutex_init(&mutex,NULL);
	}

	~MutexLock()
	{
		pthread_mutex_destroy(&mutex);
	}

	void lock()
	{
		pthread_mutex_lock(&mutex);
	}

	void unlock()
	{
		pthread_mutex_unlock(&mutex);
	}
private:
	pthread_mutex_t mutex;
};

 考虑继续扩充控制线程同步的类。