c++ - Boost asio TCP 异步服务器不异步？

Question

我正在使用 Boost example 中提供的代码.

服务器一次只接受 1 个连接。这意味着，在当前连接关闭之前不会有新连接。

如何让上面的代码同时接受无限制的连接？

#include <cstdlib>
#include <iostream>
#include <memory>
#include <utility>
#include <boost/asio.hpp>

using boost::asio::ip::tcp;

class session
  : public std::enable_shared_from_this<session>
{
public:
  session(tcp::socket socket)
    : socket_(std::move(socket))
  {
  }

  void start()
  {
    do_read();
  }

private:
  void do_read()
  {
    auto self(shared_from_this());
    socket_.async_read_some(boost::asio::buffer(data_, max_length),
        [this, self](boost::system::error_code ec, std::size_t length)
        {
          if (!ec)
          {
            boost::this_thread::sleep(boost::posix_time::milliseconds(10000));//sleep some time
            do_write(length);
          }
        });
  }

  void do_write(std::size_t length)
  {
    auto self(shared_from_this());
    boost::asio::async_write(socket_, boost::asio::buffer(data_, length),
        [this, self](boost::system::error_code ec, std::size_t /*length*/)
        {
          if (!ec)
          {
            do_read();
          }
        });
  }

  tcp::socket socket_;
  enum { max_length = 1024 };
  char data_[max_length];
};

class server
{
public:
  server(boost::asio::io_service& io_service, short port)
    : acceptor_(io_service, tcp::endpoint(tcp::v4(), port)),
      socket_(io_service)
  {
    do_accept();
  }

private:
  void do_accept()
  {
    acceptor_.async_accept(socket_,
        [this](boost::system::error_code ec)
        {
          if (!ec)
          {
            std::make_shared<session>(std::move(socket_))->start();
          }

          do_accept();
        });
  }

  tcp::acceptor acceptor_;
  tcp::socket socket_;
};

int main(int argc, char* argv[])
{
  try
  {
    if (argc != 2)
    {
      std::cerr << "Usage: async_tcp_echo_server <port>\n";
      return 1;
    }

    boost::asio::io_service io_service;

    server s(io_service, std::atoi(argv[1]));

    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

如您所见，程序等待休眠，同时不会获取第二个连接。

Answer 1

您正在处理程序中进行同步等待，该处理程序在为您的 io_service 服务的唯一线程上运行。这使得 Asio 等待调用处理程序以处理任何新请求。

1. 使用 deadline_time 和 wait_async，或者，

   void do_read() {
       auto self(shared_from_this());
       socket_.async_read_some(boost::asio::buffer(data_, max_length),
                               [this, self](boost::system::error_code ec, std::size_t length) {
           if (!ec) {
               timer_.expires_from_now(boost::posix_time::seconds(1));
               timer_.async_wait([this, self, length](boost::system::error_code ec) {
                       if (!ec)
                           do_write(length);
                   });
           }
       });
   }
   

   其中 timer_ 字段是 session

   的 boost::asio::deadline_timer 成员

2. 作为穷人的解决方案，添加更多线程(这只是意味着如果同时到达的请求多于处理它们的线程，它仍然会阻塞，直到第一个线程可用以接管请求新请求)

   boost::thread_group tg;
   for (int i=0; i < 10; ++i)
       tg.create_thread([&]{ io_service.run(); });
   
   tg.join_all();