我可以在多线程I/O服务超时的情况下使用boost.asio同步读取套接字吗？

Question

我有一个应用程序使用boost.asio进行TCP和UDP套接字通信。我知道“asio”中的“a”代表异步，因此库倾向于鼓励您在可能的情况下使用异步I/O。我有几个情况下，同步套接字读取是可取的。然而，同时，我想设置一个超时的所述接收调用，这样就不会有可能读阻塞无限期。

这在boost.asio用户中似乎是一个相当常见的问题，在这个主题中有以下过去的堆栈溢出问题：

null

std::size_t receive(const boost::asio::mutable_buffer& buffer,
      boost::posix_time::time_duration timeout, boost::system::error_code& ec)
  {
    // Set a deadline for the asynchronous operation.
    deadline_.expires_from_now(timeout);

    // Set up the variables that receive the result of the asynchronous
    // operation. The error code is set to would_block to signal that the
    // operation is incomplete. Asio guarantees that its asynchronous
    // operations will never fail with would_block, so any other value in
    // ec indicates completion.
    ec = boost::asio::error::would_block;
    std::size_t length = 0;

    // Start the asynchronous operation itself. The handle_receive function
    // used as a callback will update the ec and length variables.
    socket_.async_receive(boost::asio::buffer(buffer),
        boost::bind(&client::handle_receive, _1, _2, &ec, &length));

    // Block until the asynchronous operation has completed.
    do io_service_.run_one(); while (ec == boost::asio::error::would_block);

    return length;
  }

但是，对于套接字的底层I/O服务已经在一个或多个后台线程中运行的情况呢？在这种情况下，不能保证异步操作的处理程序会由上面代码段中的前台线程运行，因此run_one()将不会返回，直到稍后一些可能不相关的处理程序执行。这将使套接字读取相当没有响应。

asio::io_service有一个poll_one()函数，它将检查服务的队列而不阻塞，但我看不出有什么好方法可以阻塞前台线程（模拟同步调用行为）直到处理程序执行，除非没有后台线程正在执行asio::io_service::run()。

我看到了两个潜在的解决方案，我都不喜欢：

>

在启动异步操作后，使用条件变量或类似构造来使前台线程阻塞。在async_receive()调用的处理程序中，用信号通知条件变量以解除对线程的阻塞。这会为每次读取引入一些锁定，这是我希望避免的，因为我希望在UDP套接字读取上实现最大可能的吞吐量。否则，它是可行的，并且可能是我会做的，除非有一个更好的方法出现。

确保套接字有自己的asio::io_service，该套接字不由任何后台线程运行。这使得在需要异步I/O的情况下更难使用套接字。

有没有其他方法来以安全的方式完成这件事的想法？

size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
    size_t count, int flags, socket_addr_type* addr,
    std::size_t* addrlen, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return 0;
  }

  // Read some data.
  for (;;)
  {
    // Try to complete the operation without blocking.
    signed_size_type bytes = socket_ops::recvfrom(
        s, bufs, count, flags, addr, addrlen, ec);

    // Check if operation succeeded.
    if (bytes >= 0)
      return bytes;

    // Operation failed.
    if ((state & user_set_non_blocking)
        || (ec != boost::asio::error::would_block
          && ec != boost::asio::error::try_again))
      return 0;

    // Wait for socket to become ready.
    if (socket_ops::poll_read(s, 0, ec) < 0)
      return 0;
  }
}

int poll_read(socket_type s, state_type state, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }

  pollfd fds;
  fds.fd = s;
  fds.events = POLLIN;
  fds.revents = 0;
  int timeout = (state & user_set_non_blocking) ? 0 : -1;
  clear_last_error();
  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
  if (result == 0)
    ec = (state & user_set_non_blocking)
      ? boost::asio::error::would_block : boost::system::error_code();
  else if (result > 0)
    ec = boost::system::error_code();
  return result;
}

Answer 1

boost.asio对future的支持可能会提供一个优雅的解决方案。当为异步操作提供boost::asio::use_future值作为其完成处理程序时，发起函数将返回一个std::future对象，该对象将接收该操作的结果。此外，如果操作失败，则error_code将转换为system_error并通过future传递给调用方。

在boost.asio C++11 Futures datytime客户端示例中，一个专用线程运行io_service，主线程启动异步操作，然后同步等待操作完成，如下所示：

std::array<char, 128> recv_buf;
udp::endpoint sender_endpoint;
std::future<std::size_t> recv_length =
  socket.async_receive_from(
      boost::asio::buffer(recv_buf),
      sender_endpoint,
      boost::asio::use_future);

// Do other things here while the receive completes.

std::cout.write(
    recv_buf.data(),
    recv_length.get()); // Blocks until receive is complete.

当使用futures时，实现带有超时的同步读取的总体方法与以前相同。不是使用同步读取，而是使用异步读取和异步等待计时器。唯一的小改动是，不是阻塞io_service或定期检查谓词，而是调用future::get()阻塞，直到操作成功或失败（如超时）为止。

如果C++11不可用，那么可以为boost.thread的future定制异步操作的返回类型，如以下答案所示。