C++ C++；用于外部服务器的客户端&；与boost:：asio协同路由同时用于外部客户端的服务器

是否可以创建一个单线程进程，其中客户端和服务器并行运行并在它们之间通信

我有一个场景，我需要既是客户机又是服务器，我们可以在任何可能的方向接收/发送数据

• 服务器（端口A）->应用程序（客户端->处理消息并发送到->服务器（端口B））->ClientA
• 服务器（端口A）处理消息并发送到客户端A

我一直在尝试使用示例中提供的boost:：asio协程修改示例，并在io_上下文或单独的io_上下文中添加一个客户端，但我正在努力解决这个问题

我尝试将客户机和服务器放在不同的线程中，但并发性也有问题。。。任何想法或片段都将不胜感激

我有一个场景，我需要既是客户机又是服务器，我们可以在任何可能的方向接收/发送数据

这对于网络应用程序来说是相当标准的

聊天服务器似乎是一个很好的例子（因为它确实向所有方向发送/接收）：

现在，作为同时启动传出连接的服务器的基本示例：

#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");
}

让我们创建一个服务器，为每个接受的会话生成一个异步会话 连接。每个会话都是一个“反向回显”服务

同时，让我们运行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));
            }
        });
}

我们运行整个程序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");
}

#包括
#包括
#定义BOOST\u BIND\u NO\u占位符
#包括
#包括
#包括
#包括
#包括
#包括
#包括
名称空间ba=boost:：asio；
使用ba：：ip：：tcp；
使用名称空间std:：literals；
静态自动常量now=&std:：chrono:：station\u clock:：now；
静态自动常数开始=现在（）；
自动记录器（标准：：字符串名称）{
返回[名称]（自动常量和参数）{
(（std：：您能否详细说明一下您遇到的并发问题，以及为什么需要单线程进程？您在线程通信机制方面有问题吗？您是否面临硬件限制？您用APP和->箭头表示的符号是什么意思？我不清楚这一切意味着什么，而且m缺少括号更让人困惑的是。我没有硬件限制，但我认为在一个线程中处理会更容易，因为我很难处理并发性…我所说的应用程序指的是我想要做的应用程序。从外部服务器和外部客户端接收/发送数据，进行一些数据处理，然后将数据发送回同一设备或其他设备。箭头mE不是消息的方向。对不起，我没有很好地解释我自己…基本上有时候我需要从服务器接收数据并回复到服务器或发送到其他客户端，有时候我需要从客户端接收数据并发送到服务器或回复到同一个客户端，所以我的想法是使用服务器创建一个应用程序在一个端口上侦听要连接的客户端和在另一个端口上连接到外部服务器的客户端。太好了，非常感谢！从您的示例中，我可以将客户端端口更改为在同一线程中连接到外部服务器。现在我需要弄清楚如何处理服务器和客户端之间的异步读取/异步写入，因为我在尝试复制看起来不像聊天。客户端必须定期向外部服务器发送消息（类似于保持活动状态）同时，从外部客户端发送数据，因此我需要绕过服务器、客户端和viceversa之间的消息。您认为我可以保持单线程逻辑吗？@laurapons当然可以。您可以使用共享数据。而且，由于您保持单线程，您甚至不需要锁定或绞合，只是为了好玩：添加了第6个使用来自服务器的共享状态以随机间隔打印来自其他5个客户端发送的示例的统计信息的客户端。现在，您可以每秒看到来自共享状态的统计信息：再次感谢您的帮助！我一直在尝试使用您的示例代码，这确实很有帮助。这些问题可能适合codereview.stackexchange、 com
#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");
}