介绍

本文是Rainer Grimm的书Concurrency with Modern C ++中一章的翻译，该书是他网站上文章的更精炼和更详尽的版本。由于整个翻译不适合本文的框架，根据对出版物的反应，我将发表其余内容。

协程

协程是可以在保持其状态的同时暂停或恢复其执行的函数。C ++中函数的发展已向前迈进了一步。协程最有可能包括 输入C ++ 20。

作为C ++ 20中的新功能引入的协程概念已经很老了。协程的概念是梅尔文康威提出的。他在1963年的编译器开发出版物中使用了这一概念，Donald Knuth将过程称为协程的特例。有时，要接受这个想法或想法是需要时间的。

使用新的关键字co_await和co_yieldC ++ 20，它用两个新概念扩展了C ++中函数执行的概念。

有了它co_await expression，就可以暂停和恢复执行了expression。co_await expression在函数中使用时，如果该函数的结果不可用，则func调用auto getResult = func()不会阻塞。代替资源消耗的阻塞，执行资源友好的等待。

co_yield expression允许您实现生成器功能。生成器是在每次后续调用中返回新值的函数。生成器函数类似于可以从中检索值的数据流。数据流可能是无止境的。因此，这些概念对于C ++中的惰性评估至关重要。

发电机功能

. getNumbers begin end inc. begin end, inc .

// greedyGenerator.cpp
#include <iostream>
#include <vector>

std::vector<int> getNumbers(int begin, int end, int inc = 1) {
    std::vector<int> numbers; // (1)
    for (int i = begin; i < end; i += inc) {
        numbers.push_back(i);
    }
    return numbers;
}

int main() {
    const auto numbers = getNumbers(-10, 11);
    for (auto n : numbers) {
        std::cout << n << " ";
    }
    std::cout << "\n";

    for (auto n : getNumbers(0, 101, 5)) {
        std::cout << n << " ";
    }
    std::cout << "\n";
}

, getNumbers , std::iota C++11.

, :

$ ./greedyGenerator
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 
0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100 

. -, numbers (. (1) ) . 5 1000 . -, getNumbers .

// lazyGenerator.cpp
#include <iostream>
#include <vector>

generator<int> generatorForNumbers(int begin, int inc = 1) {
    for (int i = begin; ; i += inc) { // (4)
        co_yield i; // (3)
    }
}

int main() {
    const auto numbers = generatorForNumbers(-10); // (1)
    for (int i = 1; i <= 20; ++i) { // (5)
        std::cout << numbers << " ";
    }
    std::cout << "\n";

    for (auto n : generatorForNumbers(0, 5)) { // (2)
        std::cout << n << " ";
    }
    std::cout << "\n";
}

: , .. . .

, getNumbers greedyGenerator.cpp std::vector<int>, generatorForNumbers lazyGenerator.cpp generator. numbers (1) generatorForNumbers(0, 5) (2) . Range-based for . , i co_yield i (. (3)) . , .

generatorForNumbers(0, 5) (. (2)) (just-in-place usage).

. generatorForNumbers , for (4) . , .., , (5) . , , (2) .

- . - , , , . , , . , .

C++20 , (first-class) (stackless).

. , .

. , .

. . (resumable functions).

.

:

• ( ).
• , .
• .
• c , , , , .
• .

, . , - 1MB Windows 2MB Linux.

• co_return
• co_await
• co_yield
• co_await expression range-based for

return . (auto), ().

, constexpr , , main .

proposal N4628.

co_return, co_yield co_await

co_return .

co_yield . generator<int> generatorForNumbers(int begin, int inc = 1) generator<int> promise p , co_yield i co_await p.yield_value(i).co_yield i . .

co_await , . exp co_await exp , , ( awaitables). exp , : await_ready, await_suspend await_resume.

C++20 2 awaitables: std::suspend_always std::suspend_never.

std::suspend_always

struct suspend_always {
    constexpr bool await_ready() const noexcept { return false; }
    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
    constexpr void await_resume() const noexcept {}
};

, awaitable std::suspend_always , await_ready false. std::suspend_never.

std::suspend_never

struct suspend_never {
    constexpr bool await_ready() const noexcept { return true; }
    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
    constexpr void await_resume() const noexcept {}
};

co_await .

Acceptor acceptor{443};
while (true) {
    Socket socket = acceptor.accept();          // blocking
    auto request = socket.read();               // blocking
    auto response = handleRequest(request);
    socket.write(response);                     // blocking
}

. 443 , , . .

co_await .

Acceptor acceptor{443};
while (true) {
    Socket socket = co_await acceptor.accept();
    auto request = co_await socket.read();
    auto response = handleRequest(request);
    co_await socket.write(response);
}

20 , . .

: promise , handle frame .

Promise .

Handle handle frame .

Frame , . promise , , (suspention point), , , .

:

1. .
2. frame .

workflow

co_return co_yield co_await .

{
    Promise promise;
    co_await promise.initial_suspend();
    try {
        < >
    } catch (...) {
        promise.unhandled_exception();
    }
FinalSuspend:
    co_await promise.final_suspend();
}

Workflow :

• 
  
  
  • frame .
  • frame .
  • promise promise.
  • promise.get_return_object() handle . .
  • promise.initial_suspend() co_await . promise suspend_never suspend_always .
  • co_await promise.initial_suspend()
• 
  
  
  • promise.get_return_object()
• co_return
  
  
  • promise.return_void() co_return co_return expression, expression void
  • 称为promise.return_value(expression)对co_return expression，其中expression比其它类型的void
  • 删除整个堆栈的已创建变量
  • 被叫promise.final_suspend()和预期co_await结果
• 协程被破坏（通过co_return，未处理的异常或通过协程句柄完成）
  
  
  • 承诺对象的析构函数称为
  • 函数参数的析构函数称为
  • 释放协程框架使用的内存
  • 将执行传递给调用者

当协程以未处理的异常结束时，将发生以下情况：

• promise.unhandled_exception()从catch块捕获并调用异常
• 所谓的promise.final_suspend()和预期co_await的结果

第2部分