C++如何使用模板实现对象池设计模式

T

acquire

release

#include <vector>
#include <queue> // 也可以用std::vector，这里用queue更符合“池”的先进先出/后进先出语义
#include <mutex>
#include <memory> // 为了智能指针示例
#include <functional> // 为了自定义创建/重置函数
#include <iostream>

// 示例：一个需要被池化的对象类型
class MyPooledObject {
public:
    int id;
    std::string name;

    MyPooledObject() : id(0), name("default") {
        std::cout << "MyPooledObject " << this << " created." << std::endl;
    }

    // 假设对象析构有开销，但我们希望避免频繁调用
    ~MyPooledObject() {
        std::cout << "MyPooledObject " << this << " destroyed." << std::endl;
    }

    // 重置对象状态，准备下次使用
    void reset() {
        id = 0;
        name = "reset_default";
        std::cout << "MyPooledObject " << this << " reset." << std::endl;
    }

    void do_work() const {
        std::cout << "MyPooledObject " << this << " (ID: " << id << ", Name: " << name << ") is doing work." << std::endl;
    }
};

template <typename T>
class ObjectPool {
public:
    // 自定义创建和重置函数，增强灵活性
    using ObjectCreator = std::function<T*()>;
    using ObjectReseter = std::function<void(T*)>;

    // 构造函数，初始化池，可以指定初始大小和自定义的创建/重置逻辑
    ObjectPool(size_t initial_size = 10,
               ObjectCreator creator = [](){ return new T(); },
               ObjectReseter reseter = [](T* obj){ obj->reset(); })
        : creator_(std::move(creator)), reseter_(std::move(reseter)) {
        std::lock_guard<std::mutex> lock(mtx_);
        for (size_t i = 0; i < initial_size; ++i) {
            pool_.push(creator_());
        }
        std::cout << "ObjectPool initialized with " << initial_size << " objects." << std::endl;
    }

    // 析构函数，清理池中所有对象
    ~ObjectPool() {
        std::lock_guard<std::mutex> lock(mtx_);
        while (!pool_.empty()) {
            T* obj = pool_.front();
            pool_.pop();
            delete obj;
        }
        std::cout << "ObjectPool destroyed, all objects cleaned up." << std::endl;
    }

    // 从池中获取一个对象
    T* acquire() {
        std::lock_guard<std::mutex> lock(mtx_);
        if (pool_.empty()) {
            // 池中无可用对象时，动态创建一个新对象
            std::cout << "Pool exhausted, creating a new object." << std::endl;
            return creator_();
        }
        T* obj = pool_.front();
        pool_.pop();
        reseter_(obj); // 在返回前重置对象状态
        std::cout << "Acquired object " << obj << " from pool." << std::endl;
        return obj;
    }

    // 将对象归还到池中
    void release(T* obj) {
        if (!obj) return; // 防止空指针
        std::lock_guard<std::mutex> lock(mtx_);
        // 实际应用中可能需要检查obj是否真的属于这个池，避免归还外部对象
        pool_.push(obj);
        std::cout << "Released object " << obj << " back to pool." << std::endl;
    }

private:
    std::queue<T*> pool_; // 存储可用对象的队列
    std::mutex mtx_;      // 线程安全锁
    ObjectCreator creator_; // 对象创建器
    ObjectReseter reseter_; // 对象重置器
};

// ---------------------- 辅助工具：RAII封装，自动归还对象 ----------------------
// 这种封装可以确保对象在使用完毕后自动归还，避免忘记release
template <typename T>
class PooledObjectGuard {
public:
    PooledObjectGuard(ObjectPool<T>& pool, T* obj) : pool_(&pool), obj_(obj) {}

    // 禁用拷贝和赋值，确保唯一所有权
    PooledObjectGuard(const PooledObjectGuard&) = delete;
    PooledObjectGuard& operator=(const PooledObjectGuard&) = delete;

    // 移动语义
    PooledObjectGuard(PooledObjectGuard&& other) noexcept
        : pool_(other.pool_), obj_(other.obj_) {
        other.pool_ = nullptr;
        other.obj_ = nullptr;
    }

    PooledObjectGuard& operator=(PooledObjectGuard&& other) noexcept {
        if (this != &other) {
            // 先释放当前持有的对象
            if (obj_) {
                pool_->release(obj_);
            }
            pool_ = other.pool_;
            obj_ = other.obj_;
            other.pool_ = nullptr;
            other.obj_ = nullptr;
        }
        return *this;
    }

    ~PooledObjectGuard() {
        if (obj_) {
            pool_->release(obj_);
        }
    }

    T* operator->() const { return obj_; }
    T& operator*() const { return *obj_; }
    T* get() const { return obj_; }

private:
    ObjectPool<T>* pool_;
    T* obj_;
};

// 辅助函数，方便创建PooledObjectGuard
template <typename T>
PooledObjectGuard<T> make_pooled_guard(ObjectPool<T>& pool) {
    return PooledObjectGuard<T>(pool, pool.acquire());
}

// ---------------------- 使用示例 ----------------------
int main() {
    // 创建一个MyPooledObject的对象池，初始大小为3
    ObjectPool<MyPooledObject> my_object_pool(3);

    std::cout << "\n--- Scenario 1: Basic Acquire/Release ---" << std::endl;
    MyPooledObject* obj1 = my_object_pool.acquire();
    obj1->id = 101;
    obj1->name = "Task A";
    obj1->do_work();
    my_object_pool.release(obj1); // 对象归还池中，会被重置

    std::cout << "\n--- Scenario 2: Reusing Object ---" << std::endl;
    MyPooledObject* obj2 = my_object_pool.acquire(); // 应该重用obj1
    obj2->id = 202; // 注意，obj2已经被重置过
    obj2->name = "Task B";
    obj2->do_work();
    my_object_pool.release(obj2);

    std::cout << "\n--- Scenario 3: Pool Exhaustion (Dynamic Growth) ---" << std::endl;
    // 获取3个对象，池子应该空了
    MyPooledObject* obj3 = my_object_pool.acquire();
    MyPooledObject* obj4 = my_object_pool.acquire();
    MyPooledObject* obj5 = my_object_pool.acquire();
    obj3->id = 3; obj4->id = 4; obj5->id = 5;
    // 此时池中没有对象了，再获取会创建新对象
    MyPooledObject* obj6 = my_object_pool.acquire(); // 会创建一个新对象
    obj6->id = 6;
    obj6->do_work();

    my_object_pool.release(obj3);
    my_object_pool.release(obj4);
    my_object_pool.release(obj5);
    my_object_pool.release(obj6);

    std::cout << "\n--- Scenario 4: Using RAII Guard ---" << std::endl;
    {
        auto guard_obj = make_pooled_guard(my_object_pool);
        guard_obj->id = 777;
        guard_obj->name = "RAII Task";
        guard_obj->do_work();
    } // guard_obj离开作用域，自动将对象归还池中

    std::cout << "\n--- End of Main ---" << std::endl;
    return 0;
}