Question

我已经为boost :: asio实现了一个非常标准的阻止api模拟和超时。这是我的主要周期：

io_service io_svc;
tcp::endpoint endpoint(tcp::v4(), m_port);
tcp::acceptor acceptor(io_svc, endpoint);

accept_helper acc_hlpr(acceptor, 5000);

while (m_bStop == false)
{
  tcp::socket socket(io_svc);

  if (acc_hlpr.accept(socket))
  {
    // do stuff

    socket.close();
  }
}

这是助手类

class accept_helper
{
public:
  accept_helper (tcp::acceptor &acc, size_t msTO) : m_timer(acc.get_io_service()), m_acceptor(acc), m_msTO(msTO) { }

  bool accept (tcp::socket &socket)
  {
    m_bTimeout = false;
    m_bAccept = false;

    m_timer.expires_from_now(boost::posix_time::milliseconds(m_msTO));
    m_timer.async_wait(boost::bind(&accept_helper::handle_timeout, this, boost::asio::placeholders::error));

    m_acceptor.async_accept(socket, boost::bind(&accept_helper::handle_accept, this));  

    m_timer.get_io_service().run_one();
    m_timer.get_io_service().reset();

    if (m_bAccept)
    {
      m_timer.cancel();
      return true;
    }
    else if (m_bTimeout)
    {
      // BOOST_ASIO_ENABLE_CANCELIO is defined
      boost::system::error_code ec;
      m_acceptor.cancel(ec);
    }

    return false;
  }

private:
  void          handle_accept (void)
  {
    boost::mutex::scoped_lock lock(m_mutex);
    m_bAccept = true;
  }

  void          handle_timeout(const boost::system::error_code & error)
  {
    if (!error)
    {
      boost::mutex::scoped_lock lock(m_mutex);
      m_bTimeout = true;
    }
  }

private:
  boost::asio::deadline_timer m_timer;
  boost::asio::ip::tcp::acceptor &m_acceptor;
  boost::mutex m_mutex;
  size_t m_msTO;
  bool m_bTimeout;
  bool m_bAccept;
};

问题是计时器只在第一次迭代时等待。在其他方面，run_one方法只是立即返回，并且没有设置标志。我试图让计时器本地，但这没有帮助。如何让计时器每次都等待？

修正版

bool accept (tcp::socket &socket)
  {
    m_bTimeout = false;
    m_bAccept = false;

    m_timer.expires_from_now(boost::posix_time::milliseconds(m_msTO));
    m_timer.async_wait(boost::bind(&accept_helper::handle_timeout, this, boost::asio::placeholders::error));

    m_acceptor.async_accept(socket, boost::bind(&accept_helper::handle_accept, this, boost::asio::placeholders::error));    

    m_timer.get_io_service().reset();
    m_timer.get_io_service().run_one();

    if (m_bAccept)
    {
      m_timer.cancel();
    }
    else if (m_bTimeout)
    {
      boost::system::error_code ec;
      m_acceptor.cancel(ec);
    }

    while (m_timer.get_io_service().run_one());

    return m_bAccept;
  }

private:
  void          handle_accept (const boost::system::error_code & error)
  {
    if (!error)
    {
      boost::mutex::scoped_lock lock(m_mutex);
      m_bAccept = true;
    }
  }

  void          handle_timeout(const boost::system::error_code & error)
  {
    if (!error)
    {
      boost::mutex::scoped_lock lock(m_mutex);
      m_bTimeout = true;
    }
  }

Answer 1

io_service::reset()函数只允许io_service从停止状态恢复运行;它不会删除任何已经排队到io_service的处理程序。在这种情况下，在io_service（async_wait和async_accept）上启动了两个操作，但只处理了一个处理程序，因为正在处理io_service的事件循环由io_service::run_one()。在下一次调用accept_helper::accept()时，将执行上一次调用的处理程序。

要解决此问题，请考虑运行io_service，直到调用了两个处理程序。某些解决方案将运行io_service完成，如此answer和Boost.Asio blocking tcp client timeout example所示。

deadline_timer只等一次

1 个答案: