Boost Asio同步提交任务：异步链完成后返回主函数的疑问

嘿，这个场景我太熟悉了！咱们先聊聊你关心的信号量方案，再给你推荐几个更贴合Boost.Asio生态的优雅解法～

信号量方案是否可行？ #

答案是可行，但需要注意线程安全和细节处理。比如用C++20的std::counting_semaphore或者Boost的信号量：

• 初始化一个计数为0的信号量，在master里调用chain后等待信号量；
• 当chain递归到n=0时，调用信号量的release()方法，唤醒master的等待。

不过这个方案有个小缺点：它属于“手动同步”，和Boost.Asio的异步编程范式贴合度不高，而且需要额外处理错误场景（比如接收失败时要确保信号量被触发，避免master永久阻塞）。

更优雅的Boost.Asio原生方案：Promise/Future #

用std::promise和std::future是更贴合异步场景的选择——它们天然用来传递异步操作的完成状态，还能优雅处理错误。

修改后的代码示例： #

首先调整master函数，创建promise并等待future：

#include <future>

void master() {
    std::promise<void> chain_completed;
    auto completion_future = chain_completed.get_future();

    // 把promise传给chain，所有权转移避免拷贝
    chain(10, std::move(chain_completed));

    // 等待整个异步链完成，这里会阻塞直到chain触发promise
    completion_future.wait();

    // 到这里就可以放心执行后续工作啦
    // Do some other work only after completion of last processor
}

然后修改chain函数，在递归结束时触发promise：

void chain(int n, std::promise<void> done_promise) {
    if (n > 0) {
        socket_.async_receive(buffer, 
            [this, n, done_promise = std::move(done_promise)](const boost::system::error_code& error) mutable {
                // 一定要处理错误！否则接收失败时promise永远不会触发，master会卡死
                if (error) {
                    done_promise.set_exception(std::make_exception_ptr(std::runtime_error(error.message())));
                    return;
                }

                // 继续递归处理下一个数据包
                chain(--n, std::move(done_promise));
                // 异步执行数据包处理器
                boost::asio::post(io_, packet_processor);
            });
    } else {
        // 所有10个数据包处理完成，通知master
        done_promise.set_value();
    }
}

进阶：用Boost.Asio的use_future简化代码 #

如果你用的是较新版本的Boost.Asio，可以用use_future这个completion token，直接让chain返回一个std::future，代码会更简洁：

#include <boost/asio/use_future.hpp>

std::future<void> chain(int n) {
    // 递归终止条件：返回已就绪的future
    if (n == 0) {
        return std::make_ready_future();
    }

    // 用use_future把async_receive转换成future，然后链式调用下一个chain
    return socket_.async_receive(buffer, boost::asio::use_future)
        .then([this, n](auto&& /* receive_result */) {
            // 先执行数据包处理器
            boost::asio::post(io_, packet_processor);
            // 递归处理剩余数据包
            return chain(--n);
        });
}

对应的master函数就变得非常简洁：

void master() {
    // 获取chain的future并等待完成
    chain(10).get();

    // 后续工作在这里执行
}

这个方案的好处是：不需要手动管理promise，错误会自动通过future的异常抛出，代码更符合现代异步编程的风格。

内容的提问来源于stack exchange，提问作者Владислав Захаров