C++ 外部服務器客戶端和外部客戶端服務器同時與 boost::asio 協程

Question

是否可以創建一個單線程進程，其中客戶端和服務器並行運行並在它們之間進行通信？

我有一個場景，我需要既是客戶端又是服務器，我們可以在任何可能的方向上接收/發送數據。

• Server (PORT A) -> APP(client-> process message and send to ->server (PORT B)) -> ClientA
• Server (PORT A) <- APP(client<- process message and send to <-server (PORT B)) <- ClientA
• 服務器（PORT A）-> APP（客戶端->處理消息並發送到服務器（PORT A）
• ClientA -> APP(server(PORT B)-> 處理消息並發送給Client A

我一直在嘗試使用示例中提供的 boost::asio 協程修改示例，並在 io_context 或單獨的 io_context 中添加一個客戶端，但我正在努力解決這個問題。

我嘗試將客戶端和服務器放在不同的線程中，但我也遇到了並發問題......任何想法或片段將不勝感激。

Answer 1

我有一個場景，我需要既是客戶端又是服務器，我們可以在任何可能的方向上接收/發送數據。

這對於聯網應用程序來說是非常標准的。

聊天服務器似乎是一個很好的例子（因為它確實在各個方向發送/接收）： https://www.boost.org/doc/libs/1_75_0/doc/html/boost_asio/examples/cpp11_examples.html# boost_asio.examples.cpp11_examples.chat

現在，作為也啟動傳出連接的服務器的准系統示例：

現場直播

讓我們創建一個服務器，它為每個接受的連接生成一個異步 session。 每個 session 都是一個“反向回顯”服務。

// echo server, multi-client
spawn(io, [&io](ba::yield_context yc) {
    tcp::acceptor acc(io, {{}, 6868});
    acc.set_option(tcp::acceptor::reuse_address(true));

    while (true) {
        tcp::socket s(io);
        acc.async_accept(s, yc);
        spawn(yc, [s = std::move(s)]
            (ba::yield_context yc) mutable {
            log("Connection from ", s.remote_endpoint());
            std::string msg;
            while (auto n = async_read_until(s, ba::dynamic_buffer(msg), "\n", yc)) {
                std::string_view vw(msg.data(), n);
                vw.remove_suffix(1); // leave '\n'
                log("Responding to ", std::quoted(vw));

                std::reverse(msg.data(), msg.data() + vw.size());

                async_write(s, ba::buffer(msg, n), yc);
                msg = msg.substr(n);
            }
        });
    }
});

同時，讓我們運行 5 個客戶端。 如果需要外部服務器，我們只需讓它們連接到我們自己的服務器即可。

這使我們能夠擁有一個獨立的演示，並將證明單線程不會導致任何阻塞。

// a random client, let's make it connect to our own server, just for this demo
for (auto client_id = 0; client_id<5; ++client_id) {
    spawn(io,
        [&io, delay, client_id, log=logger("client #" + std::to_string(client_id))]
        (ba::yield_context yc) {
            tcp::resolver r(io);
            tcp::socket s(io);
            async_connect(s, r.async_resolve("127.0.0.1", "6868", yc), yc);

            while (true) {
                delay(yc);
                ba::streambuf buf;
                std::ostream(&buf)
                    << "Hello from client #" << client_id << "\n";

                async_write(s, buf, yc);

                std::string response;
                async_read_until(s, ba::dynamic_buffer(response), "\n", yc);
                if (!response.empty())
                    response.pop_back();

                log("Received response ", std::quoted(response));
            }
        });
}

其中delay是隨機延遲（500..1500ms）：

auto delay = [&io](ba::yield_context yc) {
    ba::steady_timer(io, 500ms + (prng() % 1000) * 1ms)
        .async_wait(yc);
};

我們運行整個程序 3 秒，然后退出：

io.run_for(3s);
logger("main")("Bye");

印刷

at     0ms  session #0  Connection from 127.0.0.1:51024
at     1ms  session #1  Connection from 127.0.0.1:51026
at     1ms  session #2  Connection from 127.0.0.1:51028
at     1ms  session #3  Connection from 127.0.0.1:51030
at     1ms  session #4  Connection from 127.0.0.1:51032
at   831ms  session #3  Responding to "Hello from client #3"
at   831ms  client #3   Received response "3# tneilc morf olleH"
at  1148ms  session #4  Responding to "Hello from client #4"
at  1148ms  client #4   Received response "4# tneilc morf olleH"
at  1196ms  session #1  Responding to "Hello from client #1"
at  1196ms  client #1   Received response "1# tneilc morf olleH"
at  1327ms  session #0  Responding to "Hello from client #0"
at  1327ms  client #0   Received response "0# tneilc morf olleH"
at  1401ms  session #2  Responding to "Hello from client #2"
at  1401ms  client #2   Received response "2# tneilc morf olleH"
at  1446ms  session #3  Responding to "Hello from client #3"
at  1446ms  client #3   Received response "3# tneilc morf olleH"
at  1836ms  session #4  Responding to "Hello from client #4"
at  1836ms  client #4   Received response "4# tneilc morf olleH"
at  2163ms  session #0  Responding to "Hello from client #0"
at  2163ms  client #0   Received response "0# tneilc morf olleH"
at  2382ms  session #2  Responding to "Hello from client #2"
at  2383ms  client #2   Received response "2# tneilc morf olleH"
at  2426ms  session #3  Responding to "Hello from client #3"
at  2426ms  client #3   Received response "3# tneilc morf olleH"
at  2444ms  session #4  Responding to "Hello from client #4"
at  2444ms  client #4   Received response "4# tneilc morf olleH"
at  2579ms  session #1  Responding to "Hello from client #1"
at  2580ms  client #1   Received response "1# tneilc morf olleH"
at  3002ms  main    Bye

完整清單

現場直播

#include <boost/asio/detail/handler_alloc_helpers.hpp>
#include <boost/system/system_error.hpp>
#define BOOST_BIND_NO_PLACEHOLDERS
#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>
#include <iostream>
#include <iomanip>
#include <thread>
#include <chrono>
#include <random>

namespace ba = boost::asio;
using ba::ip::tcp;

using namespace std::literals;

static auto const now = &std::chrono::steady_clock::now;
static auto const start = now();

auto logger(std::string name) {
    return [name](auto const&... args) {
        ((std::cout << "at" << std::setw(6) << (now() - start)/1ms << "ms\t"
                    << name << "\t") 
            << ... << args) << std::endl;
    };
}

int main() {
    ba::io_context io;

    static std::mt19937 prng { std::random_device{}() };

    // insert random async delays
    auto delay = [&io](auto yc) {
        ba::steady_timer(io, 500ms + (prng() % 1000) * 1ms)
            .async_wait(yc);
    };

    // echo server, multi-client
    spawn(io, [&io, log=logger("accept")](ba::yield_context yc) {
        tcp::acceptor acc(io, {{}, 6868});
        acc.set_option(tcp::acceptor::reuse_address(true));

        auto num_clients = 0;
        while (true) {
            tcp::socket s(io);
            acc.async_accept(s, yc);
            spawn(yc, [s = std::move(s), log=logger("session #" + std::to_string(num_clients++))]
                (ba::yield_context yc) mutable {
                log("Connection from ", s.remote_endpoint());
                std::string msg;
                while (auto n = async_read_until(s, ba::dynamic_buffer(msg), "\n", yc)) {
                    std::string_view vw(msg.data(), n);
                    vw.remove_suffix(1); // leave '\n'
                    log("Responding to ", std::quoted(vw));

                    std::reverse(msg.data(), msg.data() + vw.size());

                    async_write(s, ba::buffer(msg, n), yc);
                    msg = msg.substr(n);
                }
            });
        }
    });

    // a random client, let's make it connect to our own server, just for this demo
    for (auto client_id = 0; client_id<5; ++client_id) {
        spawn(io,
            [&io, delay, client_id, log=logger("client #" + std::to_string(client_id))]
            (ba::yield_context yc) {
                tcp::resolver r(io);
                tcp::socket s(io);
                async_connect(s, r.async_resolve("127.0.0.1", "6868", yc), yc);

                while (true) {
                    delay(yc);
                    ba::streambuf buf;
                    std::ostream(&buf)
                        << "Hello from client #" << client_id << "\n";

                    async_write(s, buf, yc);

                    std::string response;
                    async_read_until(s, ba::dynamic_buffer(response), "\n", yc);
                    if (!response.empty())
                        response.pop_back();

                    log("Received response ", std::quoted(response));
                }
            });
    }

    io.run_for(3s);
    logger("main")("Bye");
}