内存池

                   单线程内存池，通过模板技术，可以给单线程池加上不同的锁，以此来实现多线程内存池

                  

#ifndef MEMORYPOOL_H
#define MEMORYPOOL_H

#include <list>

template <typename T>
/**
 * @brief The MemoryPool class 单线程
 */
class MemoryPool
{
public:
    MemoryPool(int _size = DEFAULTSIZE);
    ~MemoryPool();
    void* alloc(size_t _size);
    void free(void* element, size_t size);
    int size() const {
        return _size;
    }
    int vaildSize() const {
        return _validsize;
    }
private:
    enum {DEFAULTSIZE = 100};
    /**
     * @brief pool 用来存放内存块的指针
     */
    std::list<void*> pool;
    void expandPool(int _len = DEFAULTSIZE);
    /**
     * @brief _size 内存池的大小
     */
    int _size;
    /**
     * @brief _validsize 可用内存块
     */
    int _validsize;
};

template <typename T>
MemoryPool<T>::MemoryPool(int _size):
    _size(0),
    _validsize(0)
{
    expandPool(_size);
}
template <typename T>
MemoryPool<T>::~MemoryPool()
{
    std::list<void*>::iterator ite = pool.begin();
    for (;ite != pool.end();++ite) {
        delete[] (*ite);
    }
}
template <typename T>
void* MemoryPool<T>::alloc(size_t /*_size*/)
{
    if (pool.empty()) {
        expandPool();
    }
    void* t = pool.front();
    pool.pop_front();
    --_validsize;
    return t;
}
template <typename T>
void MemoryPool<T>::free(void *element, size_t /*size*/)
{
    pool.push_back(element);
    ++_validsize;
}
template <typename T>
void MemoryPool<T>::expandPool(int _len)
{
    for (int i = 0;i < _len;++i) {
        pool.push_back(static_cast<void*>(new char[sizeof(T)]));
    }
    _validsize += _len;
    _size += _len;
}


#endif // MEMORYPOOL_H


#ifndef MTMEMORYPOOL_H
#define MTMEMORYPOOL_H


/**
 *mp 单线程内存池， locker为锁
 */
template <typename MP, typename Locker>
/**
 * @brief The MTmemoryPool class 多线程
 */
class MTmemoryPool
{
public:
    MTmemoryPool() {}
    ~MTmemoryPool(){}
    void* alloc(size_t size) {
        lock.lock();
        void *r = pool.alloc(size);
        lock.unlock();
        return r;
    }
    void free(void* element, size_t size) {
        lock.lock();
        pool.free(element,size);
        lock.unlock();
    }

    int size() const {
        return pool.size();
    }

private:
    MP pool;
    Locker lock;
};

#endif // MTMEMORYPOOL_H