异步操作的 Asio 处理程序在其同步对应项正常工作时不会调用

Asio handler of async operations are not called while their sync counterparts work fine

本文关键字：工作 常工作 调用 程序 处理 Asio 同步 异步操作      更新时间：2023-10-16

我正在编写一些基于ASIO的网络代码(独立，没有提升)。我已经编写了一些具有同步工作流程的测试代码，这些代码按预期工作。但是当我尝试异步(基本上用asio::async_read_until替换asio::read_until)时，永远不会调用完成处理程序：

auto receive = [&](auto self)
{
asio::async_read_until(socket, buf, 'n', [&](auto const& err, auto read)
{
std::string s;
std::istream is(&buf);
std::getline(is, s);
std::cout << "received: "" << s << ""nn";
if (socket.is_open())
self(self);
});
};

socket是tcp::socket，buf是asio::streambuf。这是我代码中唯一已更改的部分，我不知道为什么此处不调用处理程序。

以下是完整的代码：

#include <asio.hpp>
#include <thread>
#include <string>
#include <string_view>
#include <iostream>
using namespace asio::ip;
using namespace std::literals;
constexpr auto IP = "127.0.0.1"sv;
constexpr auto Service = "50000"sv;
constexpr unsigned short Port = 50000;
void server()
{
asio::io_context context;
std::thread t([&context] { context.run(); });
tcp::acceptor acceptor(context, tcp::endpoint(tcp::v4(), Port));
auto socket = acceptor.accept();
std::cout << "Server connected.n";
asio::streambuf buf;
auto receive = [&](auto self)
{
asio::async_read_until(socket, buf, 'n', [&](auto const& err, auto read)
{
std::string s;
std::istream is(&buf);
std::getline(is, s);
std::cout << "received: "" << s << ""nn";
if (socket.is_open())
self(self);
});
};
receive(receive);;
while (socket.is_open())
std::this_thread::sleep_for(1s);
std::cout << "Server shutdown.n";
context.stop();
t.join();
}
void client()
{
asio::io_context context;
std::thread t([&context] { context.run(); });
auto endpoints = tcp::resolver(context).resolve(IP, Service);
tcp::socket socket(context);
asio::connect(socket, endpoints);
std::cout << "Client connected.n";
std::string msg;
asio::streambuf buf;
std::getline(std::cin, msg);
while (!msg.empty())
{
std::ostream os(&buf);
os << msg << "n";
auto written = asio::write(socket, buf);
if (written != msg.size() + 1)
std::cout << "Couldn't send message.";
std::getline(std::cin, msg);
}
context.stop();
t.join();
}

int main()
{
std::thread t1(server);
std::thread t2(client);
t1.join();
t2.join();
return 0;
}

编辑

看起来没有异步操作对我有用。如果我使接受器异步，它的处理程序永远不会被调用(尽管客户端能够连接到套接字)。

这些是所做的更改(在server()函数内)：

tcp::acceptor acceptor(context, tcp::endpoint(tcp::v4(), Port));
acceptor.async_accept([&](auto const& err, tcp::socket sock)
{
socket = std::move(sock);
cv.notify_one();
});
{
std::mutex m;
std::unique_lock lk(m);
cv.wait(lk);
}

我可以肯定的是，我已经在 lambda 中设置了一个断点，但它尚未被触发。

第一个问题：当没有任何待处理任务要执行时，run结束。在您的情况下run是在启动第一个异步任务之前启动的。run已完成，无法调用处理程序。溶液？使用work对象，它可以防止run在没有任何任务时结束。

asio::io_context context;
asio::io_context::work work{context};
std::thread t([&context] { context.run(); });

由于work已弃用，因此您可以使用executor_work_guard：

asio::executor_work_guard<decltype(context.get_executor())> work{context.get_executor()};

或者仅在使用 C++17 时采用较短的形式：

asio::executor_work_guard work{context.get_executor()};

但是这种方法有一个问题，t.join将永远等待。 必须摧毁work，这样run才能结束。我们不能用局部变量来实现这种行为。

但是使用智能指针我们可以做到：

std::unique_ptr< asio::io_context::work> work = 
std::make_unique< asio::io_context::work>(context);
std::thread t([&context] { context.run(); });
... the rest code
context.stop();
work.reset();
t.join();

第二个问题是在lambda中：

auto receive = [&](auto self)
{
asio::async_read_until(socket, buf, 'n', [&](auto const& err, auto read)
{                                         ^^^^
std::string s;
std::istream is(&buf);
std::getline(is, s);
std::cout << "received: "" << s << ""nn";
if (socket.is_open())
self(self);
});
};

您通过[&]引用捕获self，这是坏主意self因为它是外部 lambda 中的本地。因为异步函数会立即返回，所以self被破坏，并且在内部 lambda 中，您有悬空的引用。 试试这个：

[self,&socket,&buf](auto const& err, auto read)
相关文章：