c++ - "co_await other_co"和 "other_co.resume"有什么区别？

Question

以下代码不符合我的预期。

#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 挂起或运行？

Answer 1

如果一个函数是协程，它只能通过以下方式之一暂停:

1. 当协程启动时，如果 promise 最初挂起。
2. 当直接调用 co_await 表达式(或等价物，如 co_yield)时。
3. 当协程 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_awaiting 和直接调用 coroutine_handle::resume 函数之间的区别。

如前所述，在初始和最终挂起点之外，仅 co_await(或等效)表达式可以导致协程挂起。在句柄上调用 resume 就像调用函数的中间部分一样。它的工作方式与任何其他函数调用一样；它进入堆栈等等。

让 co_await 恢复协程是不同的。当 await_suspend 返回协程句柄时，这会用调用堆栈上恢复的协程替换您的协程。这就是暂停协程的全部意义所在。