我正在查找Asio套接字文档，但是我找不到有关如何处理以下情况的任何有用信息：
我假设在对等网络中有很多服务器（最多1000个）。服务器将定期彼此通信，因此我不想每次需要时都打开新的客户端连接以发送消息到另一个服务器（巨大的开销）。
同时，创建n个线程，每个线程对应一个客户端->服务器连接也不是真正可行的。
我将实现不同的通信方案（全互连、星型和树形），因此1、log(n)和n个服务器将必须实例化这些n个套接字客户端以创建与其他服务器的连接。
有什么好方法可以简单地执行以下伪代码吗。
pool = ConnectionPool.create(vector<IP>);
pool.sendMessage(ip, message);
我知道在服务器端可以使用异步连接。然而，我不知道如何从C++/Asio的“客户端”（发送方）角度处理它。
Tl:DR;
当我想要向N个服务器“发送”消息时，每次都不必打开N个连接，也不使用N个线程时，应该使用哪些API和类？
是的，每个进程都需要一个服务器端（用于接收来自任何n个参与者的消息）和一个客户端（用于向任何n个参与者发送消息）。然而，在Asio中，我所能找到的唯一发送消息到k个n个参与者的方法是通过创建k个连接的k个线程。
那么你可能没有找对地方，或者根本没有很远地寻找。
异步IO的核心原则是在单个线程上多路复用IO（所有kqueue / epoll / select / IO完成端口等抽象都面向该目标）。
这是一个非常简单的演示，展示了：
on a heartbeat interval we send all the peers a heartbeat message
for (auto& peer : peers)
async_write(peer, buffer(message), [ep=peer.remote_endpoint(ec)](error_code ec, size_t xfr) {
std::cout << "(sent " << xfr << " bytes to " << ep << "(" << ec.message() << ")" << std::endl;
});
#include <boost/asio.hpp>
#include <list>
#include <iostream>
using std::tuple;
using namespace std::literals;
template <typename T>
static auto reference_eq(T const& obj) {
return [p=&obj](auto& ref) { return &ref == p; };
}
int main() {
using namespace boost::asio; // don't be this lazy please
using boost::system::error_code;
using ip::tcp;
io_context ioc;
tcp::acceptor listener(ioc, {{}, 6868});
listener.set_option(tcp::acceptor::reuse_address(true));
listener.listen();
using Loop = std::function<void()>;
std::list<tcp::socket> clients, peers;
// accept unbounded clients
Loop accept_loop = [&] {
listener.async_accept([&](error_code const& ec, tcp::socket s) {
if (!ec) {
std::cout << "New session " << s.remote_endpoint() << std::endl;
clients.push_back(std::move(s));
accept_loop();
}
});
};
tcp::resolver resoler(ioc);
for (auto [host,service] : {
tuple{"www.example.com", "http"},
{"localhost", "6868"},
{"::1", "6868"},
// ...
})
{
auto& p = peers.emplace_back(ioc);
async_connect(p, resoler.resolve(host,service), [&,spec=(host+":"s+service)](error_code ec, auto...) {
std::cout << "For " << spec << " (" << ec.message() << ")";
if (!ec)
std::cout << " " << p.remote_endpoint();
else
peers.remove_if(reference_eq(p));
std::cout << std::endl;
});
}
std::string const& message = "heartbeat\n";
high_resolution_timer timer(ioc);
Loop heartbeat = [&]() mutable {
timer.expires_from_now(2s);
timer.async_wait([&](error_code ec) {
std::cout << "heartbeat " << ec.message() << std::endl;
if (ec)
return;
for (auto& peer : peers)
async_write(peer, buffer(message), [ep=peer.remote_endpoint(ec)](error_code ec, size_t xfr) {
std::cout << "(sent " << xfr << " bytes to " << ep << "(" << ec.message() << ")" << std::endl;
});
heartbeat();
});
};
signal_set sigs(ioc, SIGINT, SIGTERM);
sigs.async_wait([&](error_code ec, int sig) {
if (!ec) {
std::cout << "signal: " << strsignal(sig) << std::endl;
listener.cancel();
timer.cancel();
} });
accept_loop();
heartbeat();
ioc.run_for(10s); // max time for Coliru, or just `run()`
}
打印（在我的系统上）：
New session 127.0.0.1:46730
For localhost:6868 (Success) 127.0.0.1:6868
For ::1:6868 (Connection refused)
For www.example.com:http (Success) 93.184.216.34:80
heartbeat Success
(sent 10 bytes to 93.184.216.34:80(Success)
(sent 10 bytes to 127.0.0.1:6868(Success)
heartbeat Success
(sent 10 bytes to 93.184.216.34:80(Success)
(sent 10 bytes to 127.0.0.1:6868(Success)
heartbeat Success
(sent 10 bytes to 93.184.216.34:80(Success)
(sent 10 bytes to 127.0.0.1:6868(Success)
^Csignal: Interrupt
heartbeat Operation canceled
由于网络访问受限，¹在coliru上无法正常工作。不使用解析程序的回送版本可行：在Coliru上实时演示
l.emplace_back(...); auto& p = l.back(); 的东西。 - sehe由于你表示想使用TCP即基于连接的协议，因此可以使用异步ASIO API，并且可以依赖于1个线程，因为异步即反应器模式调用不会阻塞。
你的服务器将使用boost::asio::ip::tcp::socket进行boost::asio::async_write，这与一个TCP连接发生相等。你作为参数给出的回调函数将在发送完成后调用，但async_write会立即返回。接收方类似于客户端。为了获得对传入客户端的TCP连接，你需要使用boost::asio::ip::tcp::resolver，它通过在客户端上监听boost::asio::ip::tcp::resolver::async_resolve并在服务器端初始化一个具有boost::asio::ip::tcp::endpoint和boost::asio::ip::tcp::acceptor::async_accept的boost::asio::ip::tcp::acceptor来为你打开新的TCP连接/套接字。实际上，你需要两个，一个用于IPv4，另一个用于IPv6。
由于在服务器端有一个TCP连接状态，您通常需要在中央位置跟踪它，但为了避免这种争用并简化模式，通常使用继承 std::enable_shared_from_this 的类，这将在回调函数中提供自身的 std::shared_pointer 到 std::async_write，以便在发送和接收之间，在线程没有被阻塞的情况下，不会被遗忘即删除。
对于读取，我建议使用 boost::asio::async_read_until 和一般的 boost::asio::streambuf。
通过运行循环中的 boost::asio::io_context::run 的1个线程就足够了，每当许多连接需要处理接收到的内容或者需要生成新的要发送的东西时，它都会解除阻塞。
总体项目有点超出范围，如果您能缩小问题的范围，或者更好地阅读演示和示例，那将会很有帮助。我写过与您所想的类似的东西，一个弹性覆盖网络：https://github.com/Superlokkus/code
shared_from_this模式，您将为boost::asio::ip::tcp::acceptor::async_accept::async_accept提供一个回调函数，该函数创建表示连接的类的新实例。 它不必将该实例放入任何东西，因为您的连接类将通过boost::asio::async_read_until开始第一个异步接收，并且该回调对象（例如lambda）将使用[me=shared_from_this()]捕获一个std::shared_ptr实例，直到您获取到数据或关闭连接。 您将没有中央连接字典。 - Superlokkusboost::asio::io_context::strand、std::atomics 或互斥锁在多个线程上运行 io_context::run，你必须在其上进行同步。 - Superlokkus