对象池与线程池(pool)

对象池技术可以避免在程序的生命期中创建和删除大量对象。如果知道程序需要同一类型的大量对象，而且对象的生命期都很短，就可以为这些对象创建一个池(pool)进行缓存。

对象池实现中最难的一方面是记录哪些对象是空闲的，哪些对象正在使用。这个实现采用了下列做法：把空闲对象的指针保存在一个队列中，每次请求一个对象，池就会把队列中的第一个对象交给客户，如果所有空闲都用完，才进行新的分配内存

另外，使用一个向量记录所有已分配的对象，这个向量仅在撤销池时才会用到，以便释放所有对象的内存，从而避免内存泄露。

#include <iostream>
#include <queue>
#include <vector>
#include <stdexcept>
#include <memory>

using std::queue;
using std::vector;

template <typename T>
class ObjectPool
{
public:
    ObjectPool(int chunkSize = kDefaultChunkSize)
        throw(std::invalid_argument, std::bad_alloc);
    ~ObjectPool();

    T& acquireObject();
    void releaseObject(T& obj);

    int getFreeNum(){ return mFreeList.size();}
protected:
    queue<T *> mFreeList;
    vector<T *> mAllObjects;

    int mChunkSize;
    static const int kDefaultChunkSize = 10;

    void allocateChunk();
    static void arrayDeleteObject(T *obj);
private:
    ObjectPool(const ObjectPool<T>& src);
    ObjectPool & operator=(const ObjectPool<T>& rhs);
};

template <typename T>
ObjectPool<T>::ObjectPool(int chunkSize) throw(std::invalid_argument, std::bad_alloc) : mChunkSize(chunkSize)
{
    if(mChunkSize <= 0)
    {
        throw std::invalid_argument("chunk size must be positive");
    }
    allocateChunk();
}

template <typename T>
void ObjectPool<T>::allocateChunk()
{
    T *newObject = new T[mChunkSize];
    mAllObjects.push_back(newObject);
    for(int i = 0; i < mChunkSize; ++i)
    {
        mFreeList.push(&newObject[i]);
    }
}

template <typename T>
void ObjectPool<T>::arrayDeleteObject(T *obj)
{
    delete [] obj;
}

template <typename T>
ObjectPool<T>::~ObjectPool()
{
    for_each(mAllObjects.begin(), mAllObjects.end(), arrayDeleteObject);
}

template <typename T>
T &ObjectPool<T>::acquireObject()
{
    std::cout << getFreeNum() << " ";
    if(mFreeList.empty())
    {
        std::cout << "failed! need allocate one again" << std::endl;
        allocateChunk();
    }
    T *pobj = mFreeList.front();
    mFreeList.pop();
    std::cout << "ok" << std::endl;
    return (*pobj);
}

template <typename T>
void ObjectPool<T>::releaseObject(T &obj)
{
    mFreeList.push(&obj);
}

class UserRequest
{
public:
    UserRequest() {}
    ~UserRequest() {}

protected:
    //
};

int main()
{
    ObjectPool<UserRequest> objpool(10);

    for(int i=0; i < 30; ++i)
    {
        UserRequest ur=objpool.acquireObject();
    }
    system("PAUSE");
    return 0;
}