C++ 中的对象池设计模式

2025年5月13日 | 阅读 9 分钟

引言

对象池设计模式是一种创建型设计模式，它通过重用系统中昂贵的（代价高昂的）对象来提高效率。该模式旨在通过维护一组已初始化的对象，而不是不断地创建和销毁对象，来提高应用程序的性能和内存利用率。当对象的创建涉及大量资源消耗或时间限制时，对象池模式在提高应用程序的有效利用率方面可以发挥重要作用。

在 C++ 应用程序中处理资源通常是一个巨大的挑战，尤其是在涉及大量网络连接或对象的情况下。应用对象池设计模式有助于降低成本、提高性能水平并妥善管理资源。

问题陈述

每个系统都有一些创建和初始化成本很高的对象类别。这方面的一个好例子是数据库连接或文件系统句柄，它们需要相当长的时间来建立。审慎地创建和删除这些对象可能会导致 C.P.U. 占用率增加、内存占用空间增大以及对系统性能产生不良影响。此外，在交易量大的情况下，资源的频繁分配和释放会导致碎片化和内存泄漏。

让我们来看一个例子： 假设你正在开发一个需要频繁使用子弹、敌人或数据库连接等对象的游戏或应用程序。每次需要一个对象时都创建一个新对象，并在不再需要时销毁它可能会浪费资源。相反，需要一种解决方案来重用不再使用的对象，从而优化内存和性能。

例如，考虑以下场景： 你正在制作一个涉及子弹、敌人或数据库连接等对象的游戏或应用程序。每次需要一个对象时不必创建一个新对象，然后在不再需要时销毁它，因为这是一种效率低下的做法。拥有一个允许删除未使用的对象以便只有所需的内存才被使用的机制效率更高。

解决方案：对象池模式

对象池模式适用于需要大量对象但又无法负担频繁创建和销毁的场景。通过对象池模式，可以维护一个“池”，其中包含预先确定的一组可重用对象。当需要一个对象时，就从池中获取，这样就无需创建全新的对象。当对象不再使用时，它会被放回池中以供重用，而不是被销毁，后者是一种浪费。这可以更好地利用资源，同时最大限度地减少与资源创建和销毁相关的成本。

它是如何工作的？

对象池 (Object Pool)： 一组有限数量的可重用对象。
获取对象 (Acquire an Object)： 这是系统在对象被从池中借用来执行各种功能时的一个过程。
释放对象 (Release an Object)： 这是在对象完成预期用途后将其返回到池中的步骤。
池管理 (Pool Management)： 通常，池负责对象的生命周期管理，并调节池中对象的数量。

在 C++ 中，实现此模式需要仔细管理内存和资源，确保在获取对象时正确初始化，并在释放时进行清理。

C++ 对象池实现

下面是一个简单的 C++ 示例，用于演示对象池模式。让我们考虑一个场景，我们有一个 DatabaseConnection 类，它模拟了一个昂贵的创建对象。我们将使用一个对象池来管理和重用 DatabaseConnection 实例。

步骤 1：创建资源类

首先，我们创建一个 DatabaseConnection 类，它代表一个数据库连接。该类具有连接和断开数据库的方法。

 
#include <iostream>

class DatabaseConnection {
public:
    DatabaseConnection() {
        // Simulate expensive connection setup
        std::cout << "Connecting to database..." << std::endl;
    }

    ~DatabaseConnection() {
        // Simulate cleanup
        std::cout << "Disconnecting from database..." << std::endl;
    }

    void query(const std::string& sql) {
        std::cout << "Executing query: " << sql << std::endl;
    }
};   

步骤 2：创建对象池类

现在，我们实现 DatabaseConnectionPool 类。该类将管理固定数量的 DatabaseConnection 对象，并允许客户端获取和释放这些对象。

 
#include <vector>
#include <memory>

class DatabaseConnectionPool {
private:
    std::vector<std::unique_ptr<DatabaseConnection>> availableConnections;
    std::vector<std::unique_ptr<DatabaseConnection>> usedConnections;

public:
    DatabaseConnectionPool(size_t poolSize) {
        for (size_t i = 0; i < poolSize; ++i) {
            availableConnections.push_back(std::make_unique<DatabaseConnection>());
        }
    }

    DatabaseConnection* acquireConnection() {
        if (availableConnections.empty()) {
            std::cout << "No available connections!" << std::endl;
            return nullptr;
        }

        auto connection = std::move(availableConnections.back());
        availableConnections.pop_back();
        usedConnections.push_back(std::move(connection));

        return usedConnections.back().get();
    }

    void releaseConnection(DatabaseConnection* connection) {
        auto it = std::find_if(usedConnections.begin(), usedConnections.end(),
                               [connection](const std::unique_ptr<DatabaseConnection>& ptr) {
                                   return ptr.get() == connection;
                               });

        if (it != usedConnections.end()) {
            availableConnections.push_back(std::move(*it));
            usedConnections.erase(it);
        }
    }
};   

步骤 3：使用对象池

以下是我们如何使用 DatabaseConnectionPool 来管理连接。

 
int main() {
    DatabaseConnectionPool pool(3);  // Create a pool with 3 connections

    DatabaseConnection* conn1 = pool.acquireConnection();
    if (conn1) conn1->query("SELECT * FROM users");

    DatabaseConnection* conn2 = pool.acquireConnection();
    if (conn2) conn2->query("INSERT INTO users (name) VALUES ('John')");

    pool.releaseConnection(conn1);
    pool.releaseConnection(conn2);

    // Acquiring again after release
    DatabaseConnection* conn3 = pool.acquireConnection();
    if (conn3) conn3->query("DELETE FROM users WHERE name = 'John'");

    pool.releaseConnection(conn3);

    return 0;
}   

程序 1

 
#include <iostream>
#include <vector>
#include <memory>
#include <algorithm>
#include <string>

// C++11 version of make_unique
template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

// The resource class that will be pooled
class DatabaseConnection {
public:
    DatabaseConnection() {
        // Simulate expensive connection setup
        std::cout << "Connecting to database..." << std::endl;
    }

    ~DatabaseConnection() {
        // Simulate cleanup
        std::cout << "Disconnecting from database..." << std::endl;
    }

    void query(const std::string& sql) {
        std::cout << "Executing query: " << sql << std::endl;
    }
};

// The Object Pool class that manages DatabaseConnection objects
class DatabaseConnectionPool {
private:
    std::vector<std::unique_ptr<DatabaseConnection>> availableConnections;
    std::vector<std::unique_ptr<DatabaseConnection>> usedConnections;

public:
    // Constructor to initialize the pool with a specific number of connections
    DatabaseConnectionPool(size_t poolSize) {
        for (size_t i = 0; i < poolSize; ++i) {
            availableConnections.push_back(make_unique<DatabaseConnection>());
        }
    }

    // Method to acquire a connection from the pool
    DatabaseConnection* acquireConnection() {
        if (availableConnections.empty()) {
            std::cout << "No available connections!" << std::endl;
            return nullptr;
        }

        auto connection = std::move(availableConnections.back());
        availableConnections.pop_back();
        usedConnections.push_back(std::move(connection));

        return usedConnections.back().get();
    }

    // Method to release a connection back to the pool
    void releaseConnection(DatabaseConnection* connection) {
        auto it = std::find_if(usedConnections.begin(), usedConnections.end(),
                               [connection](const std::unique_ptr<DatabaseConnection>& ptr) {
                                   return ptr.get() == connection;
                               });

        if (it != usedConnections.end()) {
            availableConnections.push_back(std::move(*it));
            usedConnections.erase(it);
        }
    }
};

int main() {
    DatabaseConnectionPool pool(3);  // Create a pool with 3 connections

    // Acquire and use a connection from the pool
    DatabaseConnection* conn1 = pool.acquireConnection();
    if (conn1) conn1->query("SELECT * FROM users");

    DatabaseConnection* conn2 = pool.acquireConnection();
    if (conn2) conn2->query("INSERT INTO users (name) VALUES ('John')");

    // Release connections back to the pool
    pool.releaseConnection(conn1);
    pool.releaseConnection(conn2);

    // Acquire a connection again, reusing one of the released connections
    DatabaseConnection* conn3 = pool.acquireConnection();
    if (conn3) conn3->query("DELETE FROM users WHERE name = 'John'");

    // Release the last connection
    pool.releaseConnection(conn3);

    return 0;
}   

输出

 
Connecting to database...
Connecting to database...
Connecting to database...
Executing query: SELECT * FROM users
Executing query: INSERT INTO users (name) VALUES ('John')
Executing query: DELETE FROM users WHERE name = 'John'
Disconnecting from database...
Disconnecting from database...
Disconnecting from database...

代码解释

DatabaseConnection 类： 表示一个连接，其构造函数模拟了昂贵的设置过程。
DatabaseConnectionPool 类
- acquireConnection： 如果可能，从可用池中获取一个连接。
- releaseConnection： 在连接不再需要时将其返回到池中。
main 函数： 它演示了从池中获取、使用和释放连接。

程序 2

 
#include <iostream>
#include <vector>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <random>
#include <chrono>
#include <algorithm> // Needed for std::find_if

// C++11 version of make_unique
template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

// A simulated "Thread" class that performs some work
class Thread {
public:
    Thread(int id) : threadID(id), active(false) {
        std::cout << "Thread " << threadID << " created.\n";
    }

    ~Thread() {
        std::cout << "Thread " << threadID << " destroyed.\n";
    }

    void performTask() {
        std::cout << "Thread " << threadID << " performing task.\n";
        active = true;
        
        // Simulate variable work time
        std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 1000 + 500));
        
        std::cout << "Thread " << threadID << " completed task.\n";
        active = false;
    }

    bool isActive() const {
        return active;
    }

    int getID() const {
        return threadID;
    }

private:
    int threadID;
    bool active;
};

// Thread-safe Object Pool for Thread objects
class ObjectPool {
public:
    ObjectPool(size_t poolSize) {
        for (size_t i = 0; i < poolSize; ++i) {
            pool.push(make_unique<Thread>(i + 1));
        }
    }

    // Acquire a Thread from the pool (blocks if no threads are available)
    std::unique_ptr<Thread> acquire() {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this]() { return !pool.empty(); });
        
        std::unique_ptr<Thread> thread = std::move(pool.front());
        pool.pop();
        
        return thread;
    }

    // Release a Thread back to the pool
    void release(std::unique_ptr<Thread> thread) {
        std::unique_lock<std::mutex> lock(mtx);
        
        pool.push(std::move(thread));
        cv.notify_one(); // Notify one waiting thread
    }

private:
    std::queue<std::unique_ptr<Thread>> pool;
    std::mutex mtx;
    std::condition_variable cv;
};

// Simulates a client requesting threads from the pool and performing tasks
void clientTask(ObjectPool& pool, int clientID) {
    auto thread = pool.acquire();

    std::cout << "Client " << clientID << " acquired Thread " << thread->getID() << ".\n";
    thread->performTask();

    std::cout << "Client " << clientID << " releasing Thread " << thread->getID() << ".\n";
    pool.release(std::move(thread));
}

int main() {
    const size_t poolSize = 3;
    const int numClients = 5;
    ObjectPool threadPool(poolSize);
    
    std::vector<std::thread> clients;
    
    for (int i = 1; i <= numClients; ++i) {
        clients.emplace_back(clientTask, std::ref(threadPool), i);
    }

    for (auto& client : clients) {
        client.join();
    }

    return 0;
}   

输出

 
Thread 1 created.
Thread 2 created.
Thread 3 created.
Client 2 acquired Thread 1.
Thread 1 performing task.
Client 3 acquired Thread 2.
Thread 2 performing task.
Client 4 acquired Thread 3.
Thread 3 performing task.
Thread 1 completed task.
Client 2 releasing Thread 1.
Client 5 acquired Thread 1.
Thread 1 performing task.
Thread 3 completed task.
Client 4 releasing Thread 3.
Client 1 acquired Thread 3.
Thread 3 performing task.
Thread 2 completed task.
Client 3 releasing Thread 2.
Thread 1 completed task.
Client 5 releasing Thread 1.
Thread 3 completed task.
Client 1 releasing Thread 3.
Thread 2 destroyed.
Thread 1 destroyed.
Thread 3 destroyed.

代码解释

Thread 类： 此类代表一个模拟线程，它执行一些工作。每个 Thread 对象都有一个 ID 和一个 active 状态，以指示它当前是否正在使用。
- performTask()： 通过睡眠一段随机时间（500 至 1500 毫秒）来模拟任务，以模仿真实世界的处理。
ObjectPool 类： 此类管理 Thread 对象的池。
- 该池初始化为具有固定数量的 Thread 对象。
- acquire()： 从池中获取一个线程。如果没有可用线程，它将阻塞直到有线程被释放回池中。
- release()： 将一个线程释放回池中，并通知等待的线程有一个线程可用。
- 互斥锁（std::mutex 和 std::condition_variable）确保在并发环境中对池的安全访问。
clientTask 函数： 它代表一个客户端对池中线程的请求。
- 每个客户端： 获取一个线程，执行任务，然后释放线程。
main 函数： 它创建了一个具有固定大小（例如，3 个线程）的 threadPool 和多个客户端（例如，5 个客户端）。每个客户端都在一个单独的线程中运行，从池中获取、使用和释放线程。

对象池模式的优点

对象池设计模式的几个优点如下：

提高性能： 重用对象而不是重新创建对象，从而减少了处理开销。
高效的资源管理： 池控制活动对象的数量，防止资源耗尽。
减少内存碎片： 通过重用对象，最大限度地减少了内存分配和释放。

对象池模式的缺点

对象池设计模式的几个缺点如下：

复杂性增加： 管理对象池逻辑会增加代码的复杂性。
内存开销： 即使对象未使用，池也会将它们保留在内存中，这可能会增加内存消耗。
潜在的资源泄漏： 如果对象未正确释放回池中，可能会导致资源泄漏。

结论

总之，对象池设计模式是 C++ 中有效管理昂贵对象的强大工具。通过重用资源，它可以提高性能、优化内存使用并减少频繁创建和销毁对象的开销。但是，需要仔细实施以确保正确的内存管理并防止资源泄漏。对象池模式非常适合需要管理有限资源（如数据库连接或大型对象）的应用程序，并且在高性能或实时系统中尤其有益。

下一个主题C++ 中的波动数

C++ 中的对象池设计模式

引言

问题陈述

解决方案：对象池模式

它是如何工作的？

C++ 对象池实现

步骤 1：创建资源类

步骤 2：创建对象池类

步骤 3：使用对象池

程序 1

代码解释

程序 2

代码解释

对象池模式的优点

对象池模式的缺点

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C++ 教程

C++ 控制语句

C++ 函数

C++ 数组

C++ 类和对象

C++ 构造函数

C++ 继承

C++ 多态

C++ 抽象

C++ 命名空间

C++ 模板

C++ 字符串

C++ 指针

信号处理

C++ 异常

C++ 文件与流

C++ STL 教程

面试题

选择题

C++ 程序

C++ STL Stack

C++ STL Bitset

C++ STL Deque

C++ STL List

C++ STL Map

C++ STL Math

C++ STL priority_queue

C++ STL Queue

C++ STL Multiset

C++ STL Multimap

C++ STL Set

C++ STD Strings

C++ STL Vector

C++ 操纵符

C++ STL Algorithms

C++ Algorithm

C++ Iterators

C++ 杂项

C++ 中的对象池设计模式

引言

问题陈述

解决方案：对象池模式

它是如何工作的？

C++ 对象池实现

步骤 1：创建资源类

步骤 2：创建对象池类

步骤 3：使用对象池

程序 1

代码解释

程序 2

代码解释

对象池模式的优点

对象池模式的缺点

结论

相关帖子

C++ Kasai 算法

C++ 超立方体排序

C++ 硬币堆

C++ Std::pmr::monotonic_buffer_resource

C++ 中的奥尔数