基于boost::asio的异步HTTP客户端多请求失效问题排查

问题现象 #

代码运行时出现错误输出、挂起或段错误，无论设置大于0的线程数（n_threads）或请求数（n_requests），问题都会复现。你怀疑std::vector::emplace_back构造std::future时违反了其不可复制的约束，但这并非问题根源。

错误根源分析 #

1. std::future的emplace_back用法合法：std::future仅支持移动语义，但emplace_back会直接在容器内部移动构造std::async返回的未来对象，不会触发复制操作，这部分代码没有问题。

2. 线程启动逻辑错误：
   代码中循环n_requests次启动线程调用io_context.run()，但实际应根据n_threads的数值启动线程。错误的线程数量会导致资源浪费或并行性不足，甚至可能因无线程处理异步任务导致异常。

3. 未触发异步请求流程：
   给出的Request构造函数中没有启动异步域名解析/连接的逻辑，导致io_context无待处理任务，run()会立即返回。如果完整代码中的handler存在非法内存访问（比如未初始化缓冲区就读写），就会引发段错误。

4. 潜在的io_context提前退出风险：
   如果异步任务启动存在延迟，io_context.run()可能在任务添加前就返回，导致任务无法被处理。

修复方案 #

1. 修正Request类，添加异步请求启动逻辑 #

确保构造函数中触发异步流程，并正确实现handler：

#include <boost/asio.hpp>
#include <future>
#include <string>
#include <vector>
#include <iostream>
#include <functional>

using ResolveResult = boost::asio::ip::tcp::resolver::results_type;
using Endpoint = boost::asio::ip::tcp::endpoint;

struct Request {
  explicit Request(boost::asio::io_context& io_context, std::string host)
      : resolver{ io_context }
      , socket{ io_context }
      , host{ std::move(host) }
  {
      // 启动异步域名解析
      resolver.async_resolve(host, "http",
          std::bind(&Request::resolution_handler, this,
              std::placeholders::_1, std::placeholders::_2));
      // 构造标准HTTP请求
      request = "GET / HTTP/1.1\r\nHost: " + this->host + "\r\nConnection: close\r\n\r\n";
  }

  void resolution_handler(boost::system::error_code ec, const ResolveResult& results) {
      if (!ec) {
          // 尝试连接第一个解析得到的端点
          boost::asio::async_connect(socket, results,
              std::bind(&Request::connection_handler, this,
                  std::placeholders::_1, std::placeholders::_2));
      } else {
          std::cerr << "Resolve error: " << ec.message() << std::endl;
      }
  }

  void connection_handler(boost::system::error_code ec, const Endpoint& /*endpoint*/) {
      if (!ec) {
          // 异步发送HTTP请求
          boost::asio::async_write(socket, boost::asio::buffer(request),
              std::bind(&Request::write_handler, this,
                  std::placeholders::_1, std::placeholders::_2));
      } else {
          std::cerr << "Connect error: " << ec.message() << std::endl;
      }
  }

  size_t write_handler(boost::system::error_code ec, size_t transferred) {
      if (!ec) {
          // 异步读取响应，使用动态缓冲区自动扩容
          boost::asio::async_read(socket, boost::asio::dynamic_buffer(response),
              std::bind(&Request::read_handler, this,
                  std::placeholders::_1, std::placeholders::_2));
      } else {
          std::cerr << "Write error: " << ec.message() << std::endl;
      }
      return transferred;
  }

  void read_handler(boost::system::error_code ec, size_t /*transferred*/) {
      if (ec && ec != boost::asio::error::eof) {
          std::cerr << "Read error: " << ec.message() << std::endl;
      }
      // 读取完成，socket会自动关闭
  }

  const std::string& get_response() const noexcept { return response; }
  const std::string& get_request() const noexcept { return request; }

private:
  boost::asio::ip::tcp::resolver resolver;
  boost::asio::ip::tcp::socket socket;
  std::string request, response;
  const std::string host;
};

2. 修正main函数的线程与io_context逻辑 #

按线程数启动线程，并使用work guard防止io_context提前退出：

int main() {
  size_t n_requests{ 2 }, n_threads{ 2 };
  boost::asio::io_context io_context;
  // 添加work guard，确保io_context在任务完成前不退出
  auto work_guard = boost::asio::make_work_guard(io_context);

  std::vector<Request> requests;
  std::generate_n(std::back_inserter(requests), n_requests, [&io_context] {
    return Request{ io_context, "example.com" };
  });

  std::cout << "debug:\n " << requests[0].get_request() << std::endl;

  std::vector<std::future<void>> futures;
  // 根据线程数启动工作线程
  for (size_t i = 0; i < n_threads; ++i) {
    futures.emplace_back(std::async(std::launch::async, [&io_context] {
      io_context.run();
    }));
  }

  // 所有请求已提交，释放work guard允许io_context在任务完成后退出
  work_guard.reset();
  // 等待所有工作线程完成
  for(auto& future : futures)
    future.get();

  // 输出响应结果
  for(size_t i = 0; i < requests.size(); ++i)
    std::cout << "Request " << i+1 << " response length: " << requests[i].get_response().size() << std::endl;
}

修复要点总结 #

• 按n_threads数量启动线程运行io_context.run()，而非请求数
• 在Request构造函数中启动异步解析流程，确保io_context有任务可处理
• 使用executor_work_guard避免io_context在异步任务添加前提前退出
• 所有handler中添加错误码处理，避免非法内存访问

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