请求增加使用示例

[Lawliet828]

What happened + What you expected to happen

想使用co_context改造之前基于muduo写的小项目，对co_context如何发请求还不太熟悉。

使用muduo发送请求时，函数声明如下

SendRequest(const std::string &ip, int port, const void *buf, size_t buf_len, Callback res_cb, Callback timeout_cb, double time);

包括收到响应后如何处理，超时如何处理两方面。

在看co_context的example后，不太明白使用co_context应该如何处理。

所以可以添加一个发送请求并有超时处理的实例代码嘛

[Codesire-Deng]

在协程的优势下，一些 callback 是可以省略的，通常的做法是将失败信息 co_return 给上层：

// Return true if successful.
// Return false if timeout or any failure occurs.
task<bool> SendRequest(
    co_context::socket socket, std::span<const char> buf, double time_ms
) {
    auto deadline = std::chrono::steady_clock::now()
                    + std::chrono::duration<double, std::milli>{time_ms};
    while (buf.size() > 0) {
        int result = co_await timeout_at(socket.send(buf), deadline);
        if (result <= 0) {
            // something wrong...
            if (-result == ECANCELED) {
                printf("timeout\n");
            }
            co_return false;
        }
        buf = buf.subspan(result); // move forward `result` bytes.
    }
    co_return true;
}

这里上层收到 false 就能知道是超时或者其他失败，从而不需要 res_cb 或者 timeout_cb 了。

[Lawliet828]

@Codesire-Deng
请教一个使用场景，比如使用muduo框架的一个服务
有一个管理线程EventLoop* manage_loop，负责处理收到的请求；
有两个执行线程EventLoop* exec_loop_1和exec_loop_2，负责执行任务。
服务收到请求先在管理线程处理，生成任务task，然后通过exec_loop_1->runInLoop将task丢给执行线程处理。

co_context如何处理以上场景，可以将任务传递给另一个线程吗？
还是说一个线程中搞3个协程，那协程之前如何传递任务呢

[Codesire-Deng]

@Lawliet828
一个 io_context 就是严格的一个线程。
最简单的办法，使用 io_context::co_spawn() 来推送任务：

#include <co_context/io_context.hpp>
#include <co_context/lazy_io.hpp>

#include <cassert>
#include <iostream>
using namespace co_context;

io_context manage_ctx;
io_context exec_ctx[2];

task<> workload(std::string message) {
    std::cout << "handling " << message << "...\n";
    co_await timeout(std::chrono::seconds(1));
    std::cout << message << " done.\n";
}

task<> manage_loop(std::vector<io_context *> workers) {
    assert(!workers.empty());
    size_t idx = 0;
    size_t count = 0;
    while (true) {
        workers[idx]->co_spawn(workload("task #" + std::to_string(count)));
        std::cout << "publish task " << count << " to exec_ctx[" << idx
                  << "]\n";
        idx = (idx + 1) % workers.size();
        ++count;
        co_await timeout(std::chrono::seconds(2));
    }
}

int main() {
    manage_ctx.co_spawn(manage_loop({&exec_ctx[0], &exec_ctx[1]}));

    manage_ctx.start();
    exec_ctx[0].start();
    exec_ctx[1].start();

    manage_ctx.join(); // 随便 join 一个，都会永久阻塞。

    return 0;
}