多线程环境下LibCurl并行HTTP请求阻塞，multi接口如何实现即时返回？

适用性说明 #

curl multi接口完全适配你的需求，它支持动态添加/移除easy handle，无需预先攒齐所有请求即可运行，且可以单独处理每个完成的请求，不需要等全部请求结束再统一返回。你现有的实现本质是每个请求独占一个线程做阻塞式easy perform，线程数量随请求量上涨时资源开销高，也无法最大化利用连接复用能力，改用multi接口可以用极少量线程（通常1个IO线程即可）支撑大量并发请求。

现有代码bug提示 #

你当前的getCurlHandleFromPool存在逻辑错误：如果连接池为空，函数会直接返回nullptr，后面的curl_easy_duphandle永远不会执行，会导致请求崩溃，需要先调整大括号逻辑。

实现思路 #

你可以采用「IO线程独立跑multi事件循环 + 调用方异步等待自己的请求结果」的架构实现单请求即时返回，核心步骤如下：

• 启动1个独立的后台IO线程，专门运行curl multi的事件循环，不需要为每个请求分配独立线程
• 每个请求提交时，从连接池取出easy handle，绑定请求独有的上下文（响应buffer、状态码存储地址、同步信号），将easy handle安全加入multi handle
• 调用方阻塞等待自己对应请求的同步信号，不需要关心其他请求的状态
• IO线程每次执行curl_multi_perform后，遍历已完成的请求，触发对应请求的同步信号，将easy handle放回连接池并从multi中移除

简化实现示例 #

#include <curl/curl.h>
#include <mutex>
#include <stack>
#include <thread>
#include <future>
#include <vector>
#include <string>

// 每个请求的私有上下文
struct RequestCtx {
    std::string* resp_buf;
    int http_code;
    std::promise<int> result_promise;
};

class CurlHttpClient {
public:
    CurlHttpClient() {
        m_base_curl = curl_easy_init();
        m_multi_handle = curl_multi_init();
        // 启动IO线程
        m_io_thread = std::thread(&CurlHttpClient::io_loop, this);
    }

    ~CurlHttpClient() {
        m_running = false;
        m_io_thread.join();
        // 资源清理逻辑省略
        curl_multi_cleanup(m_multi_handle);
        curl_easy_cleanup(m_base_curl);
    }

    // 对外请求接口，调用后阻塞到当前请求完成即返回
    int request(const std::string& url, std::string& resp_buf) {
        CURL* handle = get_handle_from_pool();
        // 设置easy handle基础参数
        curl_easy_setopt(handle, CURLOPT_URL, url.c_str());
        curl_easy_setopt(handle, CURLOPT_WRITEDATA, &resp_buf);

        // 绑定请求上下文
        auto* ctx = new RequestCtx();
        ctx->resp_buf = &resp_buf;
        curl_easy_setopt(handle, CURLOPT_PRIVATE, ctx);

        std::future<int> fut = ctx->result_promise.get_future();
        // 加锁往multi里加handle
        {
            std::scoped_lock lock(m_multi_mtx);
            curl_multi_add_handle(m_multi_handle, handle);
        }
        // 阻塞等待当前请求完成
        int code = fut.get();
        return code;
    }

private:
    CURL* m_base_curl = nullptr;
    CURLM* m_multi_handle = nullptr;
    std::thread m_io_thread;
    bool m_running = true;
    std::mutex m_pool_mtx;
    std::mutex m_multi_mtx;
    std::stack<CURL*> m_handle_pool;

    static size_t write_cb(char* ptr, size_t size, size_t nmemb, std::string* buf) {
        buf->append(ptr, size * nmemb);
        return size * nmemb;
    }

    CURL* get_handle_from_pool() {
        std::scoped_lock lock(m_pool_mtx);
        if (!m_handle_pool.empty()) {
            auto* h = m_handle_pool.top();
            m_handle_pool.pop();
            curl_easy_reset(h);
            // 重新设置通用参数，比如写回调
            curl_easy_setopt(h, CURLOPT_WRITEFUNCTION, write_cb);
            return h;
        }
        auto* new_h = curl_easy_duphandle(m_base_curl);
        curl_easy_setopt(new_h, CURLOPT_WRITEFUNCTION, write_cb);
        return new_h;
    }

    void return_handle_to_pool(CURL* h) {
        std::scoped_lock lock(m_pool_mtx);
        m_handle_pool.push(h);
    }

    void io_loop() {
        int running_handles = 0;
        while (m_running) {
            // 加锁执行multi perform，避免和加handle的操作冲突
            {
                std::scoped_lock lock(m_multi_mtx);
                curl_multi_perform(m_multi_handle, &running_handles);
            }

            // 处理已完成的请求
            CURLMsg* msg;
            int msgs_left;
            while ((msg = curl_multi_info_read(m_multi_handle, &msgs_left))) {
                if (msg->msg == CURLMSG_DONE) {
                    CURL* handle = msg->easy_handle;
                    RequestCtx* ctx;
                    curl_easy_getinfo(handle, CURLINFO_PRIVATE, &ctx);
                    // 拿HTTP状态码
                    curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &ctx->http_code);
                    // 触发请求完成信号
                    ctx->result_promise.set_value(ctx->http_code);
                    // 从multi移除handle，放回池子
                    {
                        std::scoped_lock lock(m_multi_mtx);
                        curl_multi_remove_handle(m_multi_handle, handle);
                    }
                    return_handle_to_pool(handle);
                    delete ctx;
                }
            }

            // 避免空转，等待事件或者超时，简化示例用sleep，生产环境可以用curl_multi_fdset + select/poll
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
    }
};

// 调用示例和你原来的完全兼容，不需要改业务逻辑
int main() {
    CurlHttpClient client;
    std::string url1 = "https://example.com/1";
    std::string url2 = "https://example.com/2";
    std::string r1, r2, r3, r4;
    std::thread t1([&] { client.request(url1, r1); });
    std::thread t2([&] { client.request(url2, r2); });
    t1.join();
    t2.join();
    return 0;
}

生产环境优化点 #

• 把IO循环里的固定sleep替换为curl_multi_timeout + curl_multi_fdset + 系统IO复用（select/poll/epoll），降低CPU占用
• 可以给请求增加超时控制，异常场景下主动终止超时请求，避免调用方无限等待
• 连接池可以增加最大上限，避免无限创建easy handle导致资源泄漏

内容的提问来源于stack exchange，提问作者samnaction