Question

我正在写一些基于ASIO的网络代码（独立，不带Boost）。我已经用同步工作流程编写了一些测试代码，该代码可以按预期工作。但是，当我尝试进行异步操作（基本上将asio::read_until替换为asio::async_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 << "\"\n\n";

        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 << "\"\n\n";

            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内设置了一个断点，但尚未触发。

Answer 1

第一个问题：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 << "\"\n\n";

        if (socket.is_open())
            self(self);
    });
};

您正在通过self引用捕获[&]，这是个坏主意，因为self位于外部lambda内部。由于 async-function 立即返回，因此self被销毁，并且在内部lambda中有悬挂的引用。试试这个：

[self,&socket,&buf](auto const& err, auto read)

异步操作的Asio处理程序不会被调用，而它们的同步对应项可以正常工作

编辑

1 个答案: