对象池

Code

C++11 C++03 两个版本的资源池

C++11

这里 std::shared_ptr get_shared() TODO

/**********************************************************************
Product: 
Project: 
Created:
Authors: 
Description: baseobjectpool
-----------------------------------------------------------------------
ChangeLog
DATE        NAME             DESCRIPTION
-----------------------------------------------------------------------
2016-9-22  hekai            initial
**********************************************************************/
#ifndef WISEOS_COMMON_OBJECTPOOL_H_
#define WISEOS_COMMON_OBJECTPOOL_H_
#include <memory>
#include <vector>
#include <functional>
#include "boost/thread.hpp"
#include "wiseos/common/error.h"
namespace ia10k {
template < typename T >
class BaseObjectPool {
 public:
    using DeleterType = std::function<void(T*)>;
    virtual void add(std::unique_ptr<T> t) {
        mutex_.lock();
        pool_.push_back(std::move(t));
        total++;
        mutex_.unlock();
    }
    virtual void sub() {
        mutex_.lock();
        if (pool_.size() == 0) {
            THROW_API_ERROR(IA_ERROR_NOTSUPPORT, 0, "there is no handle to sub", "");
        }
        pool_.pop_back();
        total_--;
        mutex_.unlock();
    }
    virtual std::unique_ptr<T, DeleterType> get() {
    if (pool_.empty()) {
        return nullptr;
    }
    if (total == 0) {
        THROW_API_ERROR(IA_ERROR_NOTSUPPORT, 0, "this type  handle is not exist", "");
    }
    std::unique_ptr<T, DeleterType> ptr(pool_.back().release(), [this](T* t) {
        mutex_.lock();
        pool_.push_back(std::unique_ptr<T>(t));
        mutex_.unlock();
    });
    pool_.pop_back();
    return std::move(ptr);
    }
    //TODO lock the date
    virtual std::shared_ptr<T> get_shared() {
        if (pool_.empty()) {
            throw std::logic_error("no more object");
        }
        auto pin = std::unique_ptr<T>(std::move(pool_.back()));
        pool_.pop_back();
        return std::shared_ptr<T>(pin.release(), [this](T* t) {
            pool_.push_back(std::unique_ptr<T>(t));
        });
    }
    virtual bool empty() const {
        return pool_.empty();
    }
    virtual size_t size() const {
        return pool_.size();
    }
    // lock
    virtual void inline lock() {
        mutex_.lock();
    }
    // unlock
    virtual void inline unlock() {
        mutex_.unlock();
    }
    // return mutex for lock section
    virtual boost::shared_mutex &mutex() {
        return mutex_;
    }
 protected:
    std::vector<std::unique_ptr<T>> pool_;
    // lock
    boost::shared_mutex mutex_;
    int total_ = 0;
};
}  // namespace ia10k
#endif  // WISEOS_COMMON_OBJECTPOOL_H_

C++03

这里资源需要自己获取，用完还给对象池
ObjectPool.h

#ifndef OBJECT_POOL_H_
#define OBJECT_POOL_H_
#include <queue>
#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>
template <typename T>
class ObjectPool
{
public:
    ObjectPool(int maxSize = 4)
        :maxSize_(maxSize),
         objSize_(0){
    }
    ~ObjectPool() {
    }
    static void array_delete_object(T* obj) {
        delete obj;
    }
    T& acquireObject(){
        if (all_objects_.empty()) {
            return NULL;
        }
        sharelock_.lock();
        if (all_objects_.empty()) {
            sharelock_.unlock();
            return NULL;
        }
        T *obj = all_objects_.front();
        all_objects_.pop();
        sharelock_.unlock();
        return (*obj);
    }
    void releaseObject(T& obj) {
        sharelock_.lock();
        all_objects_.push(&obj);
        sharelock_.unlock();
    }
    int addObj(T *obj) {
        sharelock_.lock();
        if (objSize_ >= maxSize_) {
            sharelock_.unlock();
            return -1;
        }
        all_objects_.push(obj);
        objSize_++;
        sharelock_.unlock();
        return 0;
    }
    T* subObj() {
        if (0 == objSize_) {
            return 0;
        }
        if (all_objects_.empty()) {
            return -1;
        }
        sharelock_.lock();
        if (0 == objSize_) {
            sharelock_.unlock();
            return 0;
        }
        if (all_objects_.empty()) {
            sharelock_.unlock();
            return -1;
        }
        T *obj = all_objects_.front();
        all_objects_.pop();
        objSize_--;
        sharelock_.unlock();
        return obj;
    }
    size_t totalSize() {
        return objSize_;
    }
    size_t queueSize() {
        return all_objects_.size();
    }
private:
    std::queue<T*> all_objects_;  
    int maxSize_;
    int objSize_;
    // lock
    boost::mutex sharelock_;
};
#endif //OBJECT_POOL_H_