持久的 ASIO 连接

Question

我正在从事一个项目，我需要能够使用一些持久性来长时间与不同的服务器通信。该服务器将具有相当高的吞吐量。我无法找到正确设置持久连接的方法。我能想到的最好方法是创建一个持久连接类。理想情况下，我会连接到服务器一次，并在信息进入我时执行 async_writes。并在信息返回给我时阅读信息。不过，我认为我的课程结构不正确。

这是我现在构建的：

persistent_connection::persistent_connection(std::string ip, std::string port):
    io_service_(), socket_(io_service_), strand_(io_service_), is_setup_(false), outbox_()
{
    boost::asio::ip::tcp::resolver resolver(io_service_);
    boost::asio::ip::tcp::resolver::query query(ip,port);
    boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
    boost::asio::ip::tcp::endpoint endpoint = *iterator;
    socket_.async_connect(endpoint, boost::bind(&persistent_connection::handler_connect, this, boost::asio::placeholders::error, iterator));
    io_service_.poll();
}

void persistent_connection::handler_connect(const boost::system::error_code &ec, boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
{
    if(ec)
    {
        std::cout << "Couldn't connect" << ec << std::endl;
        return;
    }
    else
    {
        boost::asio::socket_base::keep_alive option(true);
        socket_.set_option(option);
        boost::asio::async_read_until(socket_, buf_ ,"\r\n\r\n", boost::bind(&persistent_connection::handle_read_headers, this, boost::asio::placeholders::error));
    }
}

void persistent_connection::write(const std::string &message)
{
    write_impl(message);
    //strand_.post(boost::bind(&persistent_connection::write_impl, this, message));
}

void persistent_connection::write_impl(const std::string &message)
{
    outbox_.push_back(message);
    if(outbox_.size() > 1)
    {
        return;
    }
    this->write_to_socket();
}

void persistent_connection::write_to_socket()
{
    std::string message = "GET /"+ outbox_[0] +" HTTP/1.0\r\n";
    message += "Host: 10.1.10.120\r\n";
    message += "Accept: */*\r\n";
    boost::asio::async_write(socket_, boost::asio::buffer(message.c_str(), message.size()), strand_.wrap(
                             boost::bind(&persistent_connection::handle_write, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)));

}

void persistent_connection::handle_write(const boost::system::error_code& ec, std::size_t bytes_transfered)
{
    outbox_.pop_front();
    if(ec)
    {
        std::cout << "Send error" << boost::system::system_error(ec).what() << std::endl;
    }
    if(!outbox_.empty())
    {
        this->write_to_socket();
    }
    boost::asio::async_read_until(socket_, buf_ ,"\r\n\r\n",boost::bind(&persistent_connection::handle_read_headers, this, boost::asio::placeholders::error));
}

我将从这里发送的第一条消息似乎可以正常发送，服务器得到它，并以有效的响应进行响应。不幸的是，我看到了两个问题：

1) 在执行 async_write 命令后，我的 handle_write 永远不会被调用，我不知道为什么。 2）程序从不读取响应，我猜这与＃1有关，因为在该函数发生之前不会调用 asyn_read_until 。 3) 我还想知道是否有人可以告诉我为什么我注释掉的 strand_.post 调用不起作用。

我猜这大部分是由于我不知道应该如何使用我的 io_service，所以如果有人能给我任何指点，我将不胜感激。如果您需要任何其他信息，我很乐意提供更多信息。

谢谢

编辑调用写入：

int main()
{
    persistent_connection p("10.1.10.220", "80");
    p.write("100");
    p.write("200");
    barrier b(1,30000); //Timed mutex, waits for 300 seconds.
    b.wait();
}

和

void persistent_connection::handle_read_headers(const boost::system::error_code &ec)
{
    std::istream is(&buf_);
    std::string read_stuff;
    std::getline(is,read_stuff);
    std::cout << read_stuff << std::endl;
}

Answer 1

所描述的行为是 io_service_ 的事件循环不再被处理的结果。

构造函数调用io_service::poll()，它将运行准备运行且不会阻塞等待工作完成的处理程序，而io_service::run() 将阻塞直到所有工作完成。因此，在轮询时，如果连接的另一端没有写入任何数据，则可能没有任何处理程序准备好运行，执行将从poll()返回。

关于线程，如果每个连接都有自己的线程，并且通信是半双工协议，比如HTTP，那么如果同步编写，应用程序代码可能会更简单。另一方面，如果每个连接都有自己的线程，但代码是异步编写的，那么请考虑处理从事件循环中抛出的异常。 Boost.Asio 的可能值得一读 effect of exceptions thrown from handlers.

另外，persistent_connection::write_to_socket() 引入了未定义的行为。调用boost::asio::async_write() 时，记录显示调用者保留缓冲区的所有权，并且必须保证缓冲区在调用处理程序之前保持有效。在这种情况下，message 缓冲区是一个自动变量，其生命周期可能在调用 persistent_connection::handle_write 处理程序之前结束。一种解决方案是通过将 message 设为成员变量来更改 message 的生命周期以匹配 persistent_connection 的生命周期。