1

在我的问题中。我是客户，我的目的只是在需要时而不是每次都在服务器上编写。

我有一个单例类（调用者类），在其中我调用我的客户端程序（客户端）在服务器上写入任何消息，然后通过一个线程调用 boost::asio::io_service::run 。我的客户端程序（客户端）也是单例类。

如果服务器已经在运行，我的程序可以正常工作。因为客户端将首先连接到服务器。但是，如果服务器重新启动或未运行，那么首先我必须在编写消息之前检查服务器是否正在运行。

要每次检查服务器是否可用，我必须调用 Caller::run() 并运行 io_service。

如果不运行 io_service，我无法检查服务器是否正在运行，因为我在程序中使用了所有同步。一切都是异步的（异步连接，同步写入）

我的问题是有时我的程序进入 +D1 状态（不间断睡眠），然后我无法关闭我的程序。这是由于 io_service() 吗？

如何在不运行 io_service 的情况下检查服务器是否开启？

 class Caller
 {
  public:

  static Caller* getInstance()
  {
   static Caller Caller;
   return &Caller;
  }

  void run() 
  {
    pWork.reset( new boost::asio::io_service::work(io_service) );

    ////////////calling client program//////////////// 
    Client::getInstance(io_service)->start();

    thread = boost::thread(boost::bind(&boost::asio::io_service::run, &io_service));
  }     

  boost::asio::io_service io_service;
  boost::shared_ptr<boost::asio::io_service::work> pWork;

  boost::thread thread;

 private:
  Caller()
  {
  }
  ~Caller()
  {
    pWork.reset();
    thread.join();
  }
}; 


///////////my client program (Singleton Class)//////////////////
//////message write function///////////

void Client::sendResponse(std::string& messag)                      
{                                                                              
  boost::system::error_code error;                                           
  boost::asio::ip::tcp::endpoint endpoint = socket().remote_endpoint(error);    

  if ( error ) 
  {                                                               
    DEBUG_2("could not write: ",boost::system::system_error(error).what());    
    this->stop(); /////this will close the socket////
    Caller::getInstance()->run();   
    //////it will call the caller program to call the  connect function of client program /////
  }                                                                           
  else
    boost::asio::async_write(                                                         
      _socket,                                                                      
      boost::asio::buffer( message.c_str(), message.size()),
      _strand.wrap(                                                                 
        boost::bind(                                                                
          &Client::writeHandler,                                             
          this,
          boost::asio::placeholders::error,                                         
          boost::asio::placeholders::bytes_transferred  
}                                                                              


 Client *Client::getInstance(boost::asio::io_service& io_service)
  {
    if (!Client)
    {
      Client = new Client(io_service);
    }
    return Client;
  }

我可以这样设计吗，我只写到服务器，不需要一次又一次地运行 io_service 。还是我需要调用 io_service::reset() 我是否以正确的方式使用工作？

我怎样才能优雅地停止或中止呢？通过调用 io_servie::stop 或加入这个线程？

4

1 回答 1

1

检测连接有效性的典型方法是async_read()在连接成功后执行。当async_read()回调指示boost::asio::error::eof错误时，您的应用程序应该做出适当的反应：

  1. 重新连接，可能有超时延迟
  2. 优雅地终止
  3. 中止

听起来您需要选项＃1。如果编写正确，您的应用程序应该只需要调用io_service::run()一次，事件循环将不断有工作要做。

如果您不想从套接字中读取以检测关闭，请实例化一个work对象并在程序执行期间将其保持在范围内。这将确保io_service始终有工作要做。当您的async_write完成处理程序因错误而被调用时，请按照前面的建议对您的应用程序做出必要的反应。

于 2013-03-14T04:31:14.213 回答