实现一个简单的多线程内存池

既然涉及到多线程问题，那么锁自然是免不了了的，下面是用锁加上以前的一个模板版本的单线程内存池实现的一个多线程内存池：

首先给出前面一个模板单线程内存池的地址点这里：

下面是多线程版本的内存池：

 1 template<class POOLTYPE, class LOCK>
 2 class MTMemoryPool{
 3 public:
 4     inline void * alloc(size_t size);
 5     inline void free(void * someMem);
 6 private:
 7     POOLTYPE stPool;
 8     LOCK theLock;
 9 };
10 
11 template<class M, class L>
12 inline
13 void * MTMemoryPool<M, L>::alloc(size_t size)
14 {
15     void * mem;
16     theLock.lock();
17     mem = stPool.alloc(size);
18     theLock.unlock();
19     return mem;
20 }
21 
22 template<class M, class L>
23 inline
24 void MTMemoryPool<M, L>::free(void * doomed)
25 {
26     theLock.lock();
27     stPool.free(doomed);
28     theLock.unlock();
29 }

这里的内存池可以使用前面一片博文的内存池
锁的话可以自己定义一个锁：

 1 class ABCLock{ //Abstract Base Class
 2 public:
 3     virtual ~ABCLock();
 4     virtual void lock() = 0;
 5     virtual void unlock() = 0;
 6     //这里预留了两个接口
 7 };
 8 
 9 class MutexLock : public ABCLock{
10 public:
11     MutexLock(){pthread_mutex_init(lock, NULL);}
12     ~MutexLock(){pthread_mutex_destroy(lock);}
13     inline void lock(){pthread_mutex_lock(lock);}
14     inline void unlock(){pthread_mutex_unlock(lock);}
15 private:
16     pthread_mutex_t lock;
17 };

简单的使用方法如下所示

 1 class Rational{
 2 public:
 3     ...
 4     static void newMemPool(){
 5         memPool = new MTMemoryPool<MemoryPool<Rational>,
 6                                     MutexLock>;
 7     }
 8 private:
 9     ...
10     static MTMemoryPool<MemoryPool<Rational>, MutexLock> * memPool;
11 };

这样一来就可以直接使用这个内存池了

 1 ...
 2 for(int j = 0; j < 500; ++j){
 3     for(int i = 0; i < 1000; ++i){
 4         array[] = new Rational(i);
 5     }
 6     for(int i = 0, i < 1000; ++i){
 7         delete array[i];
 8     }
 9 }
10 ...

大体上就是这样。