在C++程序开发中，频繁的动态内存分配和对象析构会带来不小的性能开销，尤其是在高并发场景或者需要大量创建临时对象的场景下，这种开销会更加明显。对象池技术的核心思想就是预先创建一批可复用的对象，当需要使用对象时从池中获取，使用完毕后归还到池中，避免反复的内存申请和释放操作。
对象池的核心设计思路
一个基础的对象池需要包含几个核心部分：存储空闲对象的容器、对象的创建逻辑、对象的获取接口、对象的归还接口。为了避免对象池无限增长，通常还需要设置池的最大容量，当池中的对象数量达到上限时，可以选择创建新对象或者等待其他线程归还对象。
基础对象池的实现
我们先实现一个非线程安全的基础对象池，适用于单线程场景下的对象复用。这里以一个简单的TestObject类为例，对象池管理该类的实例。
#include <iostream>
#include <vector>
#include <memory>
// 待复用的测试对象类
class TestObject {
public:
TestObject() {
std::cout << "TestObject 构造" << std::endl;
}
~TestObject() {
std::cout << "TestObject 析构" << std::endl;
}
void doWork() {
std::cout << "TestObject 执行工作" << std::endl;
}
};
// 基础对象池类
template <typename T>
class ObjectPool {
private:
std::vector<std::unique_ptr<T>> freeObjects; // 存储空闲对象的容器
size_t maxSize; // 对象池最大容量
public:
// 构造函数，设置最大容量，默认100
explicit ObjectPool(size_t max = 100) : maxSize(max) {}
// 获取对象
std::unique_ptr<T> getObject() {
if (!freeObjects.empty()) {
// 从空闲列表中取出对象
auto obj = std::move(freeObjects.back());
freeObjects.pop_back();
return obj;
}
// 空闲列表为空，创建新对象
return std::make_unique<T>();
}
// 归还对象
void returnObject(std::unique_ptr<T> obj) {
if (freeObjects.size() < maxSize) {
// 池未满，将对象放回空闲列表
freeObjects.push_back(std::move(obj));
}
// 池已满，对象会自动析构，释放内存
}
// 获取当前空闲对象数量
size_t getFreeCount() const {
return freeObjects.size();
}
};
int main() {
ObjectPool<TestObject> pool(5);
// 第一次获取对象，池为空会创建新对象
auto obj1 = pool.getObject();
obj1->doWork();
std::cout << "当前空闲对象数: " << pool.getFreeCount() << std::endl;
// 归还对象
pool.returnObject(std::move(obj1));
std::cout << "归还后空闲对象数: " << pool.getFreeCount() << std::endl;
// 再次获取对象，会复用之前归还的对象
auto obj2 = pool.getObject();
obj2->doWork();
std::cout << "再次获取后空闲对象数: " << pool.getFreeCount() << std::endl;
return 0;
}
线程安全对象池的实现
上面的基础对象池没有考虑线程安全问题，在多线程场景下同时获取和归还对象会出现数据竞争。我们可以通过互斥锁来保证操作的原子性，实现线程安全的对象池。
#include <iostream>
#include <vector>
#include <memory>
#include <mutex>
#include <thread>
class TestObject {
public:
TestObject() {}
void doWork(int threadId) {
std::cout << "线程 " << threadId << " 使用对象执行工作" << std::endl;
}
};
template <typename T>
class ThreadSafeObjectPool {
private:
std::vector<std::unique_ptr<T>> freeObjects;
size_t maxSize;
std::mutex mtx; // 互斥锁保证线程安全
public:
explicit ThreadSafeObjectPool(size_t max = 100) : maxSize(max) {}
std::unique_ptr<T> getObject() {
std::lock_guard<std::mutex> lock(mtx); // 加锁
if (!freeObjects.empty()) {
auto obj = std::move(freeObjects.back());
freeObjects.pop_back();
return obj;
}
return std::make_unique<T>();
}
void returnObject(std::unique_ptr<T> obj) {
std::lock_guard<std::mutex> lock(mtx); // 加锁
if (freeObjects.size() < maxSize) {
freeObjects.push_back(std::move(obj));
}
}
size_t getFreeCount() {
std::lock_guard<std::mutex> lock(mtx);
return freeObjects.size();
}
};
// 多线程测试函数
void testPool(ThreadSafeObjectPool<TestObject>& pool, int threadId) {
auto obj = pool.getObject();
obj->doWork(threadId);
pool.returnObject(std::move(obj));
}
int main() {
ThreadSafeObjectPool<TestObject> pool(10);
std::vector<std::thread> threads;
// 创建5个线程同时获取和归还对象
for (int i = 0; i < 5; ++i) {
threads.emplace_back(testPool, std::ref(pool), i);
}
for (auto& t : threads) {
t.join();
}
std::cout << "最终空闲对象数: " << pool.getFreeCount() << std::endl;
return 0;
}
对象池的优化方向
基础的对象池实现可以满足大部分简单场景的需求，在实际项目中还可以根据需求做进一步优化：
- 支持自定义对象初始化逻辑，在获取对象时可以对对象进行重置，避免旧数据影响使用
- 增加对象池的扩容和缩容策略，根据空闲对象的数量动态调整池的容量
- 针对不同类型的对象实现对象池工厂，统一管理多个不同类型的对象池
- 如果对象创建成本很高，可以在对象池初始化时就预创建一批对象，避免第一次获取时的创建开销
使用注意事项
对象池并不是所有场景都适用，只有在对象创建和销毁成本较高、对象会被频繁重复使用的场景下，使用对象池才能带来明显的性能提升。如果对象的生命周期很短，或者创建成本很低，使用对象池反而会增加额外的管理开销。另外，归还对象时需要确保对象的状态被正确重置，避免后续复用对象时出现逻辑错误。