Boost.Asio多线程异步场景下定时器调度与非阻塞等待问题求解

你当前遇到的死锁风险核心来自两个设计缺陷：

• Asio的io_context在单线程运行时，所有异步回调会在该线程串行执行，一旦某个回调（比如你代码里timer2的reply.get()）进入阻塞等待状态，整个调度队列都会被挂起，负责触发got_response的timer3回调永远没有执行机会，最终造成永久死锁
• Reply结构体中用while(!ready) this_thread::yield()的忙等逻辑会大量占用CPU资源，没有必要

你可以通过独立io_context隔离调度域的方式实现响应逻辑的线程隔离：
将负责触发响应的定时器（或实际生产环境中的远程请求客户端）绑定到独立的io_context实例，用单独的线程池运行该实例，和业务逻辑的io_context完全隔离，不管业务侧调度线程是否被阻塞，响应侧的调度都不会受影响。
修改后的核心代码示例：

// 新增独立的响应调度io_context
io::io_context response_ctx;
// 单独开线程跑响应调度
thread response_th([&] { response_ctx.run(); });

// timer3绑定到独立的response_ctx，不会被业务侧的阻塞影响
io::steady_timer timer3(response_ctx, std::chrono::seconds(10));
timer3.async_wait([&](const boost::system::error_code &ec)
                  {
                      cout << "timer 3, thread name: " << this_thread::get_id() << endl;
                      reply.got_response(1337);
                  });

// 最后记得join响应线程
response_th.join();

这种方案下就算业务侧的io_context只开1个线程被timer2的阻塞调用占满，timer3的回调依然会在独立的response_th线程执行，不会出现死锁。

替换忙等为条件变量 #

把Reply中的忙等逻辑替换为条件变量+互斥锁的组合，大幅降低CPU占用：

struct Reply
{
    bool ready = false;
    int result = 0;
    mutex mtx;
    condition_variable cv;
    future<void> future_result;

    void call()
    {
        cout << "retry called!" << endl;
        future_result = async([&]()
                              {
                                  unique_lock<mutex> lock(mtx);
                                  cv.wait(lock, [&] { return ready; });
                              });
    }

    int get()
    {
        future_result.wait();
        return result;
    }

    void got_response(int res)
    {
        unique_lock<mutex> lock(mtx);
        result = res;
        ready = true;
        cv.notify_all();
    }
};

完全异步化（推荐方案） #

遵循Asio的异步编程范式，不要在异步回调中调用任何阻塞方法，把timer2后续的逻辑拆成独立回调，在got_response中触发，全程无阻塞，就算io_context单线程运行也不会出现死锁：

// 修改Reply，支持传入回调
struct Reply
{
    int result = 0;
    function<void(int)> callback;

    void set_callback(function<void(int)> cb) {
        callback = move(cb);
    }

    void got_response(int res)
    {
        result = res;
        if (callback) callback(result);
    }
};

// 调用侧不需要阻塞等待
timer2.async_wait([&](const boost::system::error_code &ec)
                  {
                      cout << "timer 2, thread name: " << this_thread::get_id() << endl;
                      reply.set_callback([](int res) { cout << res << endl; });
                  });

这种方案完全不需要额外的线程、忙等或者阻塞逻辑，是异步IO场景下的最佳实践。

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