Boost::asio - 如何中断阻塞的 TCP 服务器线程？

我正在开发一个多线程应用程序，其中一个线程充当从客户端接收命令的 TCP 服务器。该线程使用 Boost 套接字和接受器来等待客户端连接，接收来自客户端的命令，将命令传递给应用程序的其余部分，然后再次等待。这是代码：

void ServerThreadFunc()
{
    using boost::asio::ip::tcp;
    boost::asio::io_service io_service;
    tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), port_no));

    for (;;)
    {
        //  listen for command connection
        tcp::socket socket(io_service);
        acceptor.accept(socket);

        //  connected; receive command
        boost::array<char,256> msg_buf;
        socket.receive(boost::asio::buffer(msg_buf));

        //  do something with received bytes here
    }
}

该线程大部分时间都被阻塞在调用上acceptor.accept()。目前，线程仅在应用程序退出时终止。不幸的是，这会在 main() 返回后导致崩溃 - 我相信是因为在单例被销毁后线程尝试访问应用程序的日志记录单例。 （诚​​实的先生，当我到达这里时，情况就是这样。）

当应用程序退出时，如何彻底关闭该线程？我读过，可以通过从另一个线程关闭套接字来中断原始套接字上的阻塞accept()调用，但这似乎不适用于Boost套接字。我尝试使用以下方法将服务器逻辑转换为异步 I/OBoost 异步 tcp echo 服务器示例 http://www.boost.org/doc/libs/1_49_0/doc/html/boost_asio/example/echo/async_tcp_echo_server.cpp，但这似乎只是交换了一个阻塞调用acceptor::accept()阻止调用io_service::run()，所以我遇到了同样的问题：一个我无法打断的阻塞呼叫。有任何想法吗？

简而言之，有两种选择：

• 将代码更改为异步（acceptor::async_accept() and async_read），通过以下方式在事件循环中运行io_service::run()，并通过取消io_service::stop().
• 强制阻塞调用以使用较低级别的机制（例如信号）进行中断。

我会推荐第一个选项，因为它更便携且更易于维护。需要理解的重要概念是io_service::run() http://www.boost.org/doc/libs/1_49_0/doc/html/boost_asio/reference/io_service/run/overload1.html只要有待处理的工作，就会阻塞。什么时候io_service::stop() http://www.boost.org/doc/libs/1_49_0/doc/html/boost_asio/reference/io_service/stop.html被调用时，它将尝试导致所有线程阻塞io_service::run()尽快返回；它不会中断同步操作，例如acceptor::accept() and socket::receive()，即使在事件循环内调用同步操作。重要的是要注意io_service::stop()是非阻塞调用，因此与阻塞的线程同步io_service::run()必须使用其他机制，例如thread::join() http://www.boost.org/doc/libs/1_49_0/doc/html/thread/thread_management.html#thread.thread_management.thread.join.

下面是一个运行 10 秒并监听端口 8080 的示例：

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <iostream>

void StartAccept( boost::asio::ip::tcp::acceptor& );

void ServerThreadFunc( boost::asio::io_service& io_service )
{
  using boost::asio::ip::tcp;
  tcp::acceptor acceptor( io_service, tcp::endpoint( tcp::v4(), 8080 ) );

  // Add a job to start accepting connections.
  StartAccept( acceptor );

  // Process event loop.
  io_service.run();

  std::cout << "Server thread exiting." << std::endl;
}

void HandleAccept( const boost::system::error_code& error,
                   boost::shared_ptr< boost::asio::ip::tcp::socket > socket,
                   boost::asio::ip::tcp::acceptor& acceptor )
{
  // If there was an error, then do not add any more jobs to the service.
  if ( error )
  {
    std::cout << "Error accepting connection: " << error.message() 
              << std::endl;
    return;
  }

  // Otherwise, the socket is good to use.
  std::cout << "Doing things with socket..." << std::endl;

  // Perform async operations on the socket.

  // Done using the socket, so start accepting another connection.  This
  // will add a job to the service, preventing io_service::run() from
  // returning.
  std::cout << "Done using socket, ready for another connection." 
            << std::endl;
  StartAccept( acceptor );
};

void StartAccept( boost::asio::ip::tcp::acceptor& acceptor )
{
  using boost::asio::ip::tcp;
  boost::shared_ptr< tcp::socket > socket(
                                new tcp::socket( acceptor.get_io_service() ) );

  // Add an accept call to the service.  This will prevent io_service::run()
  // from returning.
  std::cout << "Waiting on connection" << std::endl;
  acceptor.async_accept( *socket,
    boost::bind( HandleAccept,
      boost::asio::placeholders::error,
      socket,
      boost::ref( acceptor ) ) );
}

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

  // Create io service.
  boost::asio::io_service io_service;

  // Create server thread that will start accepting connections.
  boost::thread server_thread( ServerThreadFunc, boost::ref( io_service ) );

  // Sleep for 10 seconds, then shutdown the server.
  std::cout << "Stopping service in 10 seconds..." << std::endl;
  boost::this_thread::sleep( boost::posix_time::seconds( 10 ) );
  std::cout << "Stopping service now!" << std::endl;

  // Stopping the io_service is a non-blocking call.  The threads that are
  // blocked on io_service::run() will try to return as soon as possible, but
  // they may still be in the middle of a handler.  Thus, perform a join on 
  // the server thread to guarantee a block occurs.
  io_service.stop();

  std::cout << "Waiting on server thread..." << std::endl;
  server_thread.join();
  std::cout << "Done waiting on server thread." << std::endl;

  return 0;
}

运行时，我打开了两个连接。这是输出：

Stopping service in 10 seconds...
Waiting on connection
Doing things with socket...
Done using socket, ready for another connection.
Waiting on connection
Doing things with socket...
Done using socket, ready for another connection.
Waiting on connection
Stopping service now!
Waiting on server thread...
Server thread exiting.
Done waiting on server thread.