Question

伪代码

def foo(x: List[_]) = x

使用带有非阻塞套接字的传统boost::asio::streambuf my_buffer; boost::asio::ip::tcp::socket my_socket; auto read_handler = [this](const boost::system::error_code& ec, size_t bytes_transferred) { // my logic }; my_socket.async_receive(my_buffer.prepare(512), read_handler);时，如果没有任何内容可以从套接字中读取，则返回-1。

但如果没有数据，recv的使用不会调用async_receive，并且无限期等待。

当没有什么可以从套接字中读取时，如何实现用read_handler调用read_handler（可能设置了错误代码）的这种逻辑（异步）？

（bytes_transferred == 0具有相同的行为）。

Answer 1

简而言之，在启动async_receive()操作后立即取消它。如果以boost::asio::error::operation_aborted作为错误调用完成处理程序，则操作被阻止。否则，读取操作已成功完成并已从套接字读取或由于其他原因而失败，例如远程对等方关闭连接。

socket.async_receive(boost::asio::buffer(buffer), handler);
socket.cancel();

在异步操作的启动功能中，将尝试进行非阻塞读取。 async_receive()文档中提到了这种微妙的行为：

无论异步操作是否立即完成，[...]

因此，如果操作立即成功完成或出错，则完成处理程序将为调用做好准备并且不可取消。另一方面，如果操作会阻塞，那么它将被排入反应堆进行监测，并在那里被取消。

通过在套接字上启用non-blocking模式，还可以获得与同步操作类似的行为。当套接字设置为非阻塞时，将阻止的同步操作将失败并显示boost::asio::error::would_block。

socket.non_blocking(true);
auto bytes_transferred = socket.receive(
    boost::asio::buffer(buffer), 0 /* flags */, error);

这是一个完整的示例demonstrating这些行为：

#include <array>
#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>

// This example is not interested in the handlers, so provide a noop function
// that will be passed to bind to meet the handler concept requirements.
void noop() {}

void print_status(
  const boost::system::error_code& error,
  std::size_t bytes_transferred)
{
  std::cout << "error = (" << error << ") " << error.message() << "; "
               "bytes_transferred = " << bytes_transferred
            << std::endl;
}

int main()
{
  using boost::asio::ip::tcp;

  // Create all I/O objects.
  boost::asio::io_service io_service;
  tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 0));
  tcp::socket socket1(io_service);
  tcp::socket socket2(io_service);

  // Connect the sockets.
  acceptor.async_accept(socket1, boost::bind(&noop));
  socket2.async_connect(acceptor.local_endpoint(), boost::bind(&noop));
  io_service.run();
  io_service.reset();

  std::array<char, 512> buffer;

  // Scenario: async_receive when socket has no data.
  //   Within the intiating asynchronous read function, an attempt to read
  //   data will be made.  If it fails, it will be added to the reactor,
  //   for monitoring where it can be cancelled.
  {
    std::cout << "Scenario: async_receive when socket has no data" 
              << std::endl;
    socket1.async_receive(boost::asio::buffer(buffer), &print_status);
    socket1.cancel();
    io_service.run();
    io_service.reset();
  }

  // Scenario: async_receive when socket has data.
  //   The operation will complete within the initiating function, and is
  //   not available for cancellation.
  {
    std::cout << "Scenario: async_receive when socket has data" << std::endl;
    boost::asio::write(socket2, boost::asio::buffer("hello"));
    socket1.async_receive(boost::asio::buffer(buffer), &print_status);
    socket1.cancel();
    io_service.run();
  }
  // One can also get the same behavior with synchronous operations by
  // enabling non_blocking mode.
  boost::system::error_code error;
  std::size_t bytes_transferred = 0;
  socket1.non_blocking(true);

  // Scenario: non-blocking synchronous read when socket has no data.
  {
    std::cout << "Scenario:  non-blocking synchronous read when socket"
                 " has no data." << std::endl;
    bytes_transferred = socket1.receive(
        boost::asio::buffer(buffer), 0 /* flags */, error);
    assert(error == boost::asio::error::would_block);
    print_status(error, bytes_transferred);
  }

  // Scenario: non-blocking synchronous read when socket has data.
  {
    std::cout << "Scenario:  non-blocking synchronous read when socket"
                 " has data." << std::endl;
    boost::asio::write(socket2, boost::asio::buffer("hello"));
    bytes_transferred = socket1.receive(
        boost::asio::buffer(buffer), 0 /* flags */, error);
    print_status(error, bytes_transferred);
  }
}

输出：

Scenario: async_receive when socket has no data
error = (system:125) Operation canceled; bytes_transferred = 0
Scenario: async_receive when socket has data
error = (system:0) Success; bytes_transferred = 6
Scenario:  non-blocking synchronous read when socket has no data.
error = (system:11) Resource temporarily unavailable; bytes_transferred = 0
Scenario:  non-blocking synchronous read when socket has no data.
error = (system:0) Success; bytes_transferred = 6

socket :: asio :: async_receive和0字节

1 个答案: