以下代码不符合我的预期。
#include <iostream>
#include <coroutine>
#include <vector>
struct symmetic_awaitable
{
std::coroutine_handle<> _next_h;
symmetic_awaitable(std::coroutine_handle<> h) : _next_h(h) {}
constexpr bool await_ready() const noexcept { return false; }
std::coroutine_handle<> await_suspend(std::coroutine_handle<>) const noexcept
{
return _next_h;
}
constexpr void await_resume() const noexcept {}
};
struct return_object : std::coroutine_handle<>
{
struct promise_type
{
return_object get_return_object()
{
return std::coroutine_handle<promise_type>::from_promise(*this);
}
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
return_object(std::coroutine_handle<promise_type> h) : std::coroutine_handle<>(h) {}
};
std::vector<return_object> co_list;
return_object fa()
{
std::cout << "fa1" << std::endl;
co_await symmetic_awaitable(co_list[1]);
std::cout << "fa2" << std::endl;
co_return;
}
return_object fb()
{
std::cout << "fb1" << std::endl;
co_await symmetic_awaitable(co_list[2]);
std::cout << "fb2" << std::endl;
co_await std::suspend_always{};
std::cout << "fb3" << std::endl;
co_return;
}
return_object fc()
{
std::cout << "fc1" << std::endl;
co_await symmetic_awaitable(co_list[1]);
std::cout << "fc2" << std::endl;
co_return;
}
int main()
{
auto a = fa();
auto b = fb();
auto c = fc();
co_list.push_back(a);
co_list.push_back(b);
co_list.push_back(c);
a.resume();
std::cout << "end" << std::endl;
a.destroy();
b.destroy();
c.destroy();
}
我认为输出会是
fa1
fb1
fc1
fb2
fa2
end
但实际输出是
fa1
fb1
fc1
fb2
end
然后我将所有 co_await symmetic_awaitable(co_list[i])
替换为 co_list[i].resume
。输出很奇怪
fa1
fb1
fc1
fb1
fc1
..... // the following is infinite loop of "fb1 fc1"
.....
.....
C++20的协程隐藏了太多的细节,除非我都清楚,否则代码无法像我期望的那样正常运行。
以下是我阅读 cppreference 后的问题:
1。 “调用者”和“恢复者”的区别是什么?
a调用b.resume()
,那么a是b的恢复者还是调用者?
2。 “暂停”的确切含义是什么?
a调用b.resume()
,那么a是挂起还是运行? a 通过 co_await
恢复 b,然后 a 挂起或运行?
最佳答案
如果一个函数是协程,它只能通过以下方式之一暂停:
- 当协程启动时,如果 promise 最初挂起。
- 当直接调用
co_await
表达式(或等价物,如co_yield
)时。 - 当协程
co_return
时,如果 promise 最终挂起。
没有别的可以导致协程挂起。 “coroutine”中的“co”代表协作式多任务处理。这意味着除非功能涉及合作,否则不会进行多任务处理。明确地。
您关于期望代码如何工作的假设似乎表明您相信协程具有某种执行堆栈。当 await_suspend
被调用时,当前协程被放入一个堆栈,当您返回的协程句柄以某种方式完成时,该堆栈将被弹出。因此,当您调用 co_await std::suspend_always{};
时,这将恢复之前挂起的协程。
这些都不是真的。除非你自己 build 那台机器。
协程系统完全且只您告诉它做什么。
调用 a.resume()
后的调用堆栈如下所示:
main()
fa()
当fa
暂停和恢复fb
时,它现在看起来像这样:
main()
fb()
fa
已消失。你暂停了它。它不再在调用堆栈上。只有当您明确要求恢复时,它才会恢复。
如果你想让fa
挂起到fb
中意味着fa
会在fb
结束后继续,那么您必须将其构建到您的协程机器中。它不只是发生;实现它是您的责任。
您的 await_suspend
代码需要获取给定的句柄(指的是 fa
)并将其存储在一个地方,当 fb
完成后,它可以恢复 fa
。这通常在 fb
的 promise 对象中,以便 final_suspend
可以恢复它(通常传递 fb
生成的数据)。请记住:无论 promise 的 final_suspend
返回什么,最终挂起点都会 co_await
,因此您可以只返回要恢复的协程的句柄。
What's the defference of "caller" and "resumer" ?
我不知道那是什么意思。我怀疑您是在问 co_await
ing 和直接调用 coroutine_handle::resume
函数之间的区别。
如前所述,在初始和最终挂起点之外,仅 co_await
(或等效)表达式可以导致协程挂起。在句柄上调用 resume
就像调用函数的中间部分一样。它的工作方式与任何其他函数调用一样;它进入堆栈等等。
让 co_await
恢复协程是不同的。当 await_suspend
返回协程句柄时,这会用调用堆栈上恢复的协程替换您的协程。这就是暂停协程的全部意义所在。
关于c++ - "co_await other_co"和 "other_co.resume"有什么区别?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/72504525/