对象池与线程池(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;

}