Socket库在C++中的连接池管理

在C++中，使用Socket库进行连接池管理需要考虑以下几个方面：

1. 创建套接字
2. 绑定套接字
3. 监听连接
4. 接受连接
5. 管理连接

下面是一个简单的示例，展示了如何使用C++的Socket库创建一个基本的连接池管理：

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

class ConnectionPool {
public:
    ConnectionPool(int pool_size, const std::string& ip, int port)
        : pool_size_(pool_size), ip_(ip), port_(port), stop_(false) {
        for (int i = 0; i < pool_size_; ++i) {
            connections_.emplace_back(create_connection());
        }
    }

    ~ConnectionPool() {
        stop();
    }

    void start() {
        for (auto& conn : connections_) {
            conn->start();
        }
    }

    void stop() {
        std::unique_lock<std::mutex> lock(mutex_);
        stop_ = true;
        cond_.notify_all();
        for (auto& conn : connections_) {
            conn->stop();
        }
        for (auto& conn : connections_) {
            conn->join();
        }
    }

    std::shared_ptr<Connection> get_connection() {
        std::unique_lock<std::mutex> lock(mutex_);
        cond_.wait(lock, [this] { return !connections_.empty() || stop_; });
        auto conn = connections_.back();
        connections_.pop_back();
        return conn;
    }

    void release_connection(std::shared_ptr<Connection> conn) {
        std::unique_lock<std::mutex> lock(mutex_);
        if (!stop_) {
            connections_.push_back(conn);
            cond_.notify_one();
        }
    }

private:
    std::vector<std::shared_ptr<Connection>> connections_;
    int pool_size_;
    std::string ip_;
    int port_;
    std::atomic<bool> stop_;
    std::mutex mutex_;
    std::condition_variable cond_;

    std::shared_ptr<Connection> create_connection() {
        auto conn = std::make_shared<Connection>();
        if (conn->init(ip_, port_)) {
            return conn;
        } else {
            return nullptr;
        }
    }
};

class Connection {
public:
    Connection() : socket_fd_(-1) {}

    ~Connection() {
        if (socket_fd_ != -1) {
            close(socket_fd_);
        }
    }

    bool init(const std::string& ip, int port) {
        socket_fd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (socket_fd_ == -1) {
            return false;
        }

        struct sockaddr_in server_addr;
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(port);
        inet_pton(AF_INET, ip.c_str(), &server_addr.sin_addr);

        if (connect(socket_fd_, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
            return false;
        }

        return true;
    }

    void start() {
        // Start a new thread to handle the connection
        std::thread([this]() {
            while (!stop_) {
                // Handle the connection
            }
        }).detach();
    }

    void stop() {
        stop_ = true;
    }

    int get_socket_fd() const {
        return socket_fd_;
    }

private:
    int socket_fd_;
    std::atomic<bool> stop_;
};

int main() {
    ConnectionPool pool(10, "127.0.0.1", 8080);
    pool.start();

    auto conn = pool.get_connection();
    // Use the connection

    pool.release_connection(conn);

    pool.stop();

    return 0;
}

这个示例中，我们创建了一个名为ConnectionPool的类，用于管理连接池。连接池中的每个连接都是一个Connection对象。我们在构造函数中创建了指定数量的连接，并在析构函数中停止所有连接。我们还提供了一个get_connection方法，用于从连接池中获取一个可用的连接，以及一个release_connection方法，用于将连接归还给连接池。

请注意，这个示例仅用于演示目的，实际应用中可能需要根据具体需求进行调整。例如，你可能需要处理错误情况、限制连接的最大数量等。