我认为这个问题的意思是“你好吗async_wat_any(timer1, timer2, ..., yield)。
另一个答案是正确的指向回调完成处理程序来提供这个，但他们没有提供胶水回到单个协程。
现在Asio's async operations 抽象出所有调用样式（callback、use_future、use_awaitable、yield_context 等）之间的差异——本质上将它们全部归为“callback”样式。
因此，您可以制作自己的异步启动，将这些粗略的草图联系在一起：
template <typename Token>
auto async_wait_any( std::vector<std::reference_wrapper<timer>> timers, Token token) {
using Result =
boost::asio::async_result<std::decay_t<Token>, void(error_code)>;
using Handler = typename Result::completion_handler_type;
Handler handler(token);
Result result(handler);
for (timer& t : timers) {
t.async_wait([=](error_code ec) mutable {
if (ec == boost::asio::error::operation_aborted)
return;
for (timer& t : timers) {
t.cancel_one();
}
handler(ec);
});
}
return result.get();
}
现在在你的协程中你可以说：
timer a(ex, 100ms);
timer b(ex, 200ms);
timer c(ex, 300ms);
async_wait_any({a, b, c}, yield);
当第一个完成时它会返回。
让我们演示
此外，使其更通用，而不是对计时器类型进行硬编码。事实上，在 Windows 环境中，您将能够使用 same interface 等待可等待对象（如 Event, Mutex, Semaphore）：
template <typename Token, typename... Waitable>
auto async_wait_any(Token&& token, Waitable&... waitable) {
using Result =
boost::asio::async_result<std::decay_t<Token>, void(error_code)>;
using Handler = typename Result::completion_handler_type;
Handler completion_handler(std::forward<Token>(token));
Result result(completion_handler);
// TODO use executors from any waitable?
auto ex = get_associated_executor(
completion_handler,
std::get<0>(std::tie(waitable...)).get_executor());
auto handler = [&, ex, ch = completion_handler](error_code ec) mutable {
if (ec != boost::asio::error::operation_aborted) {
(waitable.cancel_one(), ...);
post(ex, [=]() mutable { ch(ec); });
}
};
(waitable.async_wait(bind_executor(ex, handler)), ...);
return result.get();
}
我们将编写一个演示协程，如下所示：
int main() {
static auto logger = [](auto name) {
return [name, start = now()](auto const&... args) {
((std::cout << name << "\t+" << (now() - start) / 1ms << "ms\t") << ... << args) << std::endl;
};
};
boost::asio::io_context ctx;
auto wg = make_work_guard(ctx);
spawn(ctx, [log = logger("coro1"),&wg](yield_context yield) {
log("started");
auto ex = get_associated_executor(yield);
timer a(ex, 100ms);
timer b(ex, 200ms);
timer c(ex, 300ms);
log("async_wait_any(a,b,c)");
async_wait_any(yield, a, b, c);
log("first completed");
async_wait_any(yield, c, b);
log("second completed");
assert(a.expiry() < now());
assert(b.expiry() < now());
// waiting again shows it expired as well
async_wait_any(yield, b);
// but c hasn't
assert(c.expiry() >= now());
// unless we wait for it
async_wait_any(yield, c);
log("third completed");
log("exiting");
wg.reset();
});
ctx.run();
}
这打印出 Live On Coliru
coro1 +0ms started
coro1 +0ms async_wait_any(a,b,c)
coro1 +100ms first completed
coro1 +200ms second completed
coro1 +300ms third completed
coro1 +300ms exiting
注意事项、注意事项
小窍门：
-
很难决定将处理程序绑定到哪个执行程序，因为可能有多个关联的执行程序。但是，由于您使用的是协程，因此您将始终获得与 yield_context 关联的正确 strand_executor
-
在调用调用者的完成令牌之前进行取消很重要，否则协程在安全之前就已经恢复，从而导致潜在的生命周期问题
-
说到这里，既然现在我们在协程之外发布异步操作，协程挂起，我们需要一个工作守卫，因为协程不工作。