"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。 "caller" 和 "resumer" 有什么区别？

a调用b.resume()，那么a是b的resumer还是调用者？

2。 “暂停”的确切含义是什么？

a调用b.resume()，然后a挂起还是运行？ a 通过 co_await 恢复 b，然后 a 被暂停或运行 ?

Answer 1

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

协程启动时，如果 promise 最初挂起。
当直接调用 co_await 表达式（或等效表达式，如 co_yield）时。
当协程 co_returns 时，如果 promise 最终挂起。

没有其他东西 可以导致协程挂起。 “coroutine”中的“co”代表协作式多任务处理。这意味着除非涉及合作的功能，否则没有多任务处理。明确地。

您关于期望代码如何工作的假设似乎表明您相信协程具有某种执行堆栈。当 await_suspend 被调用时，当前协程被放入一个堆栈，当协程处理您 returned 以某种方式完成时，该堆栈将被弹出。因此，当您调用 co_await std::suspend_always{}; 时，这将恢复之前挂起的协程。

None 是真的。除非你自己建造那台机器。

协程系统完全只你告诉它做什么。

调用 a.resume() 后的调用堆栈如下所示：

main()
fa()

当 fa 暂停和恢复 fb 时，现在看起来像这样：

main()
fb()

fa 消失了。你暂停了它。它不再在调用堆栈上。只有当您明确要求恢复它时，它才会被恢复。

如果您希望 fa 暂停到 fb 意味着 fa 将在 fb 完成后继续，那么您必须 build 将其放入您的协程机器中。它不只是发生；实现它是你的责任。

您的 await_suspend 代码需要获取给定的句柄（指的是 fa）并将其存储在 fb 完成后可以恢复的位置fa。这通常在 fb 的承诺对象中，以便 final_suspend 可以恢复它（通常传递 fb 生成的数据）。请记住：final-suspend 点将 co_await 在任何承诺的 final_suspend return 上，因此您可以 return 您想要恢复的协程的句柄。

What's the defference of "caller" and "resumer" ?

我不知道那是什么意思。我怀疑您是在问 co_await 处理某事和直接调用 coroutine_handle::resume 函数之间有什么区别。

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

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

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

What's the difference of "co_await other_co" and "other_co.resume"?

c++

coroutine

c++20

1。 "caller" 和 "resumer" 有什么区别？

2。 “暂停”的确切含义是什么？