如何在Boost.Beast中实现HTTPS连接的持久化复用？

看起来你现在的核心痛点是：3万次请求发往同一服务器，每次新建连接导致延迟太高，想复用连接但之前的thread-local尝试导致崩溃。我来帮你一步步解决这个问题。

现有代码的问题分析 #

你当前的httpPost函数每次调用都会新建io_context、ssl::context和stream，用完就直接关闭socket——这完全没法实现连接复用。之前尝试把这些对象设为thread-local但崩溃，大概率是因为没有正确维护连接的状态（比如连接是否存活、是否匹配当前请求的服务器），也没处理io_context的重启和连接异常的情况。

解决方案：线程本地连接池 #

因为Boost.Asio的IO对象（比如ssl_stream）不是线程安全的，所以每个线程维护自己的独立连接是最安全的方案。我们可以用thread_local为每个线程创建一个包含连接状态的结构体，每次请求时先检查是否可以复用现有连接，不行再重建。

步骤1：定义线程本地连接结构体 #

首先，创建一个thread_local的结构体，包含连接所需的所有对象和状态：

thread_local struct ThreadPersistentConn {
    net::io_context io_ctx;
    ssl::context ssl_ctx;
    beast::ssl_stream<beast::tcp_stream> stream;
    tcp::resolver resolver;
    string proto, host, port;
    bool is_connected = false;

    // 构造函数初始化上下文
    ThreadPersistentConn() 
        : ssl_ctx(ssl::context::tlsv12_client), 
          stream(io_ctx, ssl_ctx),
          resolver(io_ctx) {
        // 必须加载根证书，否则HTTPS证书验证会失败（你之前注释掉了这步，这很关键）
        load_root_certificates(ssl_ctx);
        ssl_ctx.set_verify_mode(ssl::verify_peer);
    }

    // 析构时自动关闭连接
    ~ThreadPersistentConn() {
        if (is_connected) {
            try {
                if (proto == "https") {
                    stream.shutdown();
                }
                beast::close_socket(beast::get_lowest_layer(stream));
            } catch (...) {
                // 忽略关闭时的异常，避免程序崩溃
            }
        }
    }
} thread_conn;

步骤2：重构httpPost函数，实现连接复用 #

修改httpPost函数，加入连接复用逻辑：

string httpPost(string url, string data) {
    array<string,4> parsed = parseUrl(url);
    http::request<http::string_body> req;
    http::response<http::string_body> resp;
    beast::flat_buffer buffer;
    TimeBytes tb;
    cr::nanoseconds elapsed;
    auto timeStart = clk.now();

    try {
        // 检查现有连接是否匹配当前请求的服务器，且连接存活
        if (thread_conn.proto != parsed[0] || 
            thread_conn.host != parsed[1] || 
            thread_conn.port != parsed[2] || 
            !thread_conn.is_connected) {
            
            // 关闭旧连接（如果存在）
            if (thread_conn.is_connected) {
                try {
                    if (thread_conn.proto == "https") {
                        thread_conn.stream.shutdown();
                    }
                    beast::close_socket(beast::get_lowest_layer(thread_conn.stream));
                } catch (...) {}
                thread_conn.is_connected = false;
            }

            // 重启io_context（防止之前的操作导致它处于stopped状态）
            thread_conn.io_ctx.restart();

            // 解析端点并建立新连接
            auto endpoints = thread_conn.resolver.resolve(parsed[1], parsed[2]);
            beast::get_lowest_layer(thread_conn.stream).connect(endpoints);

            // HTTPS握手
            if (parsed[0] == "https") {
                SSL_set_tlsext_host_name(thread_conn.stream.native_handle(), parsed[1].c_str());
                thread_conn.stream.handshake(net::ssl::stream_base::client);
            }

            // 更新连接状态
            thread_conn.proto = parsed[0];
            thread_conn.host = parsed[1];
            thread_conn.port = parsed[2];
            thread_conn.is_connected = true;
        }

        // 构造请求（保持Connection: keep-alive）
        req.method(http::verb::post);
        req.target(parsed[3]);
        req.set(http::field::host, parsed[1]);
        req.set(http::field::connection, "keep-alive");
        req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);
        req.set(http::field::content_type, "application/json");
        req.set(http::field::accept, "application/json");
        req.body() = data;
        req.prepare_payload();

        // 发送请求
        http::write(thread_conn.stream, req);
        // 读取响应
        http::read(thread_conn.stream, buffer, resp);

        // 统计耗时和数据量
        elapsed = clk.now() - timeStart;
        tb.ms = elapsed.count() / 1e6;
        tb.bytes = req.body().size() + resp.body().size() + 7626;
        
        lock_guard<mutex> lock(timeBytesMutex);
        timeBytes.push_back(tb);

        // DEBUG输出
        if (DEBUG_QUERY) {
            cout << parsed[0] << "|\n" << parsed[1] << "|\n" << parsed[2] << "|\n" << parsed[3] << "|\n";
            cout << data << "|\n";
        }
    } catch (...) {
        // 请求失败，标记连接不可用（下次请求会重建）
        thread_conn.is_connected = false;
        // 这里可以根据需要添加错误日志
    }

    return resp.body();
}

关键注意事项 #

1. 根证书加载：必须调用load_root_certificates(ssl_ctx)，否则HTTPS连接的证书验证会失败，导致握手出错。你之前注释掉了这步，这是必须补上的。
2. 连接状态检查：每次请求前都要验证现有连接是否匹配当前服务器，并且是否存活。如果请求失败（比如抛出异常），要标记is_connected = false，下次请求会自动重建连接。
3. io_context重启：每次重建连接前调用io_ctx.restart()，因为如果之前的连接关闭或出错，io_context可能处于stopped状态，无法处理新的IO操作。
4. 线程安全：因为用了thread_local，每个线程的连接都是独立的，不会出现多线程访问同一IO对象的问题，完全符合Boost.Asio的线程安全要求。
5. GET请求复用：你的httpGet函数可以复用同样的逻辑，只需要修改请求方法为http::verb::get即可，不需要重复写连接管理的代码。

最终效果 #

这样修改后，每个线程会复用同一个连接发送所有发往同一服务器的请求，直到连接断开或服务器主动关闭。这会大大减少TCP握手和TLS协商的耗时，提升整体请求效率。

当所有请求完成后，线程退出时thread_local的ThreadPersistentConn会自动析构，关闭连接，无需手动处理。

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