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方法，用于將連接歸還給連接池。

請注意，這個示例僅用于演示目的，實際應用中可能需要根據具體需求進行調整。例如，你可能需要處理錯誤情況、限制連接的最大數量等。