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的生命周期改为与persistent_connection相匹配，方法是将其作为成员变量。

持久的ASIO连接

1 个答案: