Boost Asio：检查套接字是否可读/可写

Question

在我的应用程序中，我必须混合使用 asio 创建的套接字和本机套接字（来自 C posgresql 库）。

我需要的是能够从特定套接字上的 boost io_service 类实例中获取通知，使其处于非阻塞可读/可写状态，但不执行实际读/写（将由 3-rd 方库完成），即有效地只做select ()/ poll ()

可以通过将 0 作为缓冲区长度传递给像async_read_some ()这样的函数来实现吗？

我做了一个快速测试，确实调用async_read_some () 的缓冲区长度为零确实调用了读取事件处理程序，但我不确定它是在通过相应的套接字句柄阻塞select ()/ poll () 之后完成的，等待真正的“可以阅读”状态。

Answer 1

这通常被称为反应器式操作。

这些可以通过提供boost::asio::null_buffers给异步操作来获得。Reactor 风格的操作提供了一种在可以执行读或写操作时获得通知的方法，并且对于与第三方库集成、使用共享内存池等很有用。Boost.Asio文档提供了一些信息和以下示例代码：

ip::tcp::socket socket(my_io_service);
...
socket.non_blocking(true);
...
socket.async_read_some(null_buffers(), read_handler);
...
void read_handler(boost::system::error_code ec)
{
  if (!ec)
  {
    std::vector<char> buf(socket.available());
    socket.read_some(buffer(buf));
  }
}

Boost.Asio 还提供了一个官方的非阻塞示例，说明了如何与想要直接在套接字上执行读写操作的库集成。

为操作提供零长度缓冲区通常会导致无操作，因为操作的完成条件将在不尝试执行任何 I/O 的情况下满足。这是一个完整的示例，演示了两者之间的区别：

ip::tcp::socket socket(my_io_service);
...
socket.non_blocking(true);
...
socket.async_read_some(null_buffers(), read_handler);
...
void read_handler(boost::system::error_code ec)
{
  if (!ec)
  {
    std::vector<char> buf(socket.available());
    socket.read_some(buffer(buf));
  }
}

输出：

#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,
  boost::asio::ip::tcp::socket& socket)
{
  std::cout << "error: " << error.message() << "; "
               "transferred: " << bytes_transferred << "; "
               "available: " << socket.available() << 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;

  // Reading into a zero-length buffer is a no-op and will be
  // considered immediately completed.
  socket1.async_receive(boost::asio::buffer(buffer, 0), 
    boost::bind(&print_status,
      boost::asio::placeholders::error,
      boost::asio::placeholders::bytes_transferred,
      boost::ref(socket1))
  );
  // Guarantee the handler runs.
  assert(1 == io_service.poll());
  io_service.reset();

  // Start a reactor-style read operation by providing a null_buffer.
  socket1.async_receive(boost::asio::null_buffers(),
    boost::bind(&print_status,
      boost::asio::placeholders::error,
      boost::asio::placeholders::bytes_transferred,
      boost::ref(socket1))
  );
  // Guarantee that the handler did not run.
  assert(0 == io_service.poll());
  // Write to the socket so that data becomes available.
  boost::asio::write(socket2, boost::asio::buffer("hello"));  
  assert(1 == io_service.poll());
}