Boost.asio 使用协程实现多个连接的 echo 服务器

您只想运行 1 接受，并仅在此之后生成会话。

更好的是，您可以使用移动套接字的重载，并指定会话的链：您不需要所有会话共享保护服务器/接受器的同一链。async_accept

无需计数循环，只需链接async_accepts：

struct Server {
    Server(asio::io_context& ioc, std::string const& file)
        : io_context_(ioc)
        , acceptor_(make_strand(ioc), Protocol::endpoint(file)) //
    {
        accept_loop();
    }

  private:
    asio::io_service&      io_context_;
  //asio::strand<Executor> strand_;
    Protocol::acceptor     acceptor_;

    void accept_loop() {
        acceptor_.async_accept(make_strand(io_context_), [this](error_code ec, Protocol::socket s) {
            if (ec != asio::error::operation_aborted)
                accept_loop();

            std::cout << "Accepted: " << ec.message();
            if (!ec)
                std::cout << " from " << s.remote_endpoint();
            std::cout << std::endl;
        });
    }
};

你会注意到，为了简化，我改变了一些其他的东西：Live On Coliru

#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>
#include <iostream>

using namespace std::chrono_literals;
using namespace std::placeholders;
namespace asio = boost::asio;

constexpr auto kTimeout = 1s;
using Protocol   = asio::local::stream_protocol;
using error_code = boost::system::error_code;

struct Session : public std::enable_shared_from_this<Session> {
    Session(Protocol::socket s) : socket_(std::move(s)) {}
    ~Session() { std::cout << __FUNCTION__ << std::endl; }

    void start(asio::yield_context yield) try {
        for (;;) {
            auto n = async_read(socket_, asio::buffer(data_), yield);

            { // simulate work
                asio::steady_timer t(yield.get_executor(), kTimeout);
                t.async_wait(yield);
            }

            n = async_write(socket_, asio::buffer(data_, n), yield);
        }
    } catch (boost::system::system_error const& se) {
        std::cerr << "Session failed: " << se.code().message() << std::endl;
    }

  private:
    Protocol::socket      socket_;
    std::array<char, 256> data_;
};

struct Server {
    Server(asio::io_context& ioc, std::string const& file)
        : io_context_(ioc)
        , acceptor_(make_strand(ioc), Protocol::endpoint(file)) //
    {
        accept_loop();
    }

  private:
    asio::io_service&      io_context_;
    Protocol::acceptor     acceptor_;

    void accept_loop() {
        acceptor_.async_accept(make_strand(io_context_), [this](error_code ec, Protocol::socket s) {
            if (ec != asio::error::operation_aborted)
                accept_loop(); // continue accepting new connections

            std::cout << "Accepted: " << ec.message() << std::endl;

            auto strand = s.get_executor(); // copy before move
            spawn(strand, bind(&Session::start, std::make_shared<Session>(std::move(s)), _1));
        });
    }
};

int main(int argc, char* argv[]) try {
    if (argc != 2) {
        std::cerr << "Usage: stream_server <file>\n"
            "*** WARNING: existing file is removed ***\n";
        return 1;
    }

    asio::io_context ioc;

    std::remove(argv[1]);
    Server s(ioc, argv[1]);

    ioc.run();
} catch (std::exception const& e) {
    std::cerr << "Exception: " << e.what() << "\n";
}

但是，简化更多！

现在，整个业务只是不必要的复杂化。毕竟，你有一个完整的 coro 帧，可以保持对象的活力。事实上，对象只不过是套接字和缓冲区。只需制作一个 coro：直播shared_ptrSession

void Session(Protocol::socket& socket, asio::yield_context yield) try {
    std::array<char, 256> data;
    for (;;) {
        auto n = async_read(socket, asio::buffer(data), yield);

        { // simulate work
            asio::steady_timer t(yield.get_executor(), kTimeout);
            t.async_wait(yield);
        }

        n = async_write(socket, asio::buffer(data, n), yield);
    }
} catch (boost::system::system_error const& se) {
    std::cerr << "Session failed: " << se.code().message() << std::endl;
}

跟

spawn(strand, bind(Session, std::move(s), _1));

旁注

另外，请记住，已经默认为 .您的方法可能没问题，因为您需要 256 字节的“消息”。但是，对我来说，这似乎不像是“回显服务器”。async_readtransfer_all

在实践中，我会：read_some

for (;;) {
    auto n = socket.async_read_some(asio::buffer(data), yield);

    { // simulate work
        asio::steady_timer t(yield.get_executor(), kTimeout);
        t.async_wait(yield);
    }

    n = async_write(socket, asio::buffer(data, n), yield);
}

最后，您要处理 EOF，因为它可能会部分成功：

for (boost::system::error_code ec; !ec;) {
    auto n = socket.async_read_some(asio::buffer(data), yield[ec]);

    if (n) { // simulate work
        asio::steady_timer t(yield.get_executor(), kTimeout);
        t.async_wait(yield);
    }

    if (!ec || ec == asio::error::eof)
        n = async_write(socket, asio::buffer(data, n), yield);
}