C++ boost:：asio:：deadline#u计时器不'；t调用处理程序

我有一个tcp客户端，它轮询服务器以获得一个有截止日期的答案，这样，如果无法到达服务器，客户端就不会被阻止。我遇到的问题是，

async\u wait

似乎从未调用其处理程序，在客户端连接失败时有效地阻止了客户端。对

tcpPoll

的每次调用都有自己的线程（这就是为什么我创建了一个新的

io\u服务

），但即使没有多线程，它似乎也无法工作。另外，

NetworkEntity

对象在其生命周期内可以多次调用

tcpPoll

我的问题是：是什么阻止了

截止时间\u计时器调用其处理程序？（以及如何修复）

以下是一些相关的代码，只要没有任何故障（连接、写入、读取），这些代码就可以正常工作（如果有点长，请原谅）：

void NetworkEntity:：stop（）
{
停止=真；
//闭合插座
//取消超时
}
无效网络实体：：检查超时（常量boost：：系统：：错误代码和错误）
{
如果（停止）
返回；
如果（timeout.expires_at（），我想您一定会被io_服务的多个实例弄糊涂了

我认为这是因为在您的代码中，您从未显示如何初始化
timeout
。并且您用于连接的
io\u服务
实例仅在
tcpPoll
函数中实例化……这让我相信您是在一个单独的io上意外注册了截止时间计时器你连跑都不跑

下面是一个实际可行的版本，注意：

它已经消除了
停止
布尔值，因为它是不必要的，并且必然会混淆
有关如何检测各种程序流，请参阅
检查超时
和
停止
的新实现
完整的代码是自包含的，只比您在问题中发布的代码多几行
#包括
#包括
#包括
使用tcp=boost:：asio:：ip:：tcp；
结构网络实体{
boost:：asio:：io_服务io_服务；
boost:：asio:：deadline\u timer timeout{io\u service}；
std:：string address=“localhost”；
std：：字符串端口=“6767”；
int超时=3；
boost：：共享\u ptr套接字\uu；
boost:：asio:：streambuf请求，应答；
无效停止（）
{
如果（插座）
{
套接字->取消（）；
套接字->关闭（）；
}
超时。取消（）；
io_服务。停止（）；
}
无效检查超时（const boost:：system:：error\u代码和错误）
{
if（error！=boost:：asio:：error:：operation\u中止）
{
停止（）；
std：：下一次是否可以让您的示例自包含？这样的错误可能很明显。这样，我们就花时间“制作”io服务、截止时间计时器、地址/端口值，“猜测”套接字将共享给一个（为什么？）而请求/应答（可能）而且，最糟糕的是，我们根据自己的经验来实现这些，而不一定是您实际如何实现的（这使得我们更难看出是什么让您绊倒了）注意！下次我同意sehe先生的观点，你离成为asio专家不远了亲爱的M先生。asio学习曲线有点难，那篇文章可能会对你有所帮助。我想你是对的，我在构造函数中初始化了
timeout\uuu
（我没有显示）使用我的主
io_服务
。当我从一个
io_服务
更改为每个线程一个时，我没有想到这一点。谢谢！
void NetworkEntity::stop()
{
    stopped_ = true;
    //close socket
    //cancel timeout
}

void NetworkEntity::check_timeout(const boost::system::error_code& error)
{
    if (stopped_)
        return;
    if (timeout_.expires_at() <= boost::asio::deadline_timer::traits_type::now())
    {
        stop();
        timeout_.expires_at(boost::posix_time::pos_infin);
        std::cout << address_ << " timed out\n";
    }
    timeout_.async_wait(boost::bind(&NetworkEntity::check_timeout, this, boost::asio::placeholders::error));
}

std::vector<std::string> NetworkEntity::tcpPoll(const char* message, const char endOfMessage)
{
    boost::asio::io_service io_service;
    stopped_ = false;
    timeout_.expires_from_now(boost::posix_time::seconds(TIMEOUT_));
    timeout_.async_wait(boost::bind(&NetworkEntity::check_timeout, this, boost::asio::placeholders::error));
    tcp::resolver resolver(io_service);
    start_connect(&io_service, resolver.resolve(tcp::resolver::query(address_, port_)), message, endOfMessage);
    io_service.run();
    //retrieve answer from class
    //return answer
}

void NetworkEntity::start_connect(boost::asio::io_service* io_service, tcp::resolver::iterator endpoint_iterator, const std::string message, const char endOfMessage)
{
    socket_.reset(new tcp::socket(*io_service));
    socket_->async_connect(endpoint_iterator->endpoint(),
        boost::bind(&NetworkEntity::handle_connect, this, io_service, boost::asio::placeholders::error, endpoint_iterator, message, endOfMessage));
}

void NetworkEntity::handle_connect(boost::asio::io_service* io_service, const boost::system::error_code& err, tcp::resolver::iterator endpoint_iterator, const std::string message, const char endOfMessage)
{
    if(stopped_)
        return;
    if (err)
    {
        std::cout << "Connect error: " << err.message() << "\n";
        stop();
    }
    else
    {
        start_write(message, endOfMessage);
    }
}

void NetworkEntity::start_write(const std::string message, const char endOfMessage)
{
    std::ostream request_stream(&request_);
    request_stream << message;
    boost::asio::async_write(*socket_, request_,
        boost::bind(&NetworkEntity::handle_write, this, boost::asio::placeholders::error, endOfMessage));
}

void NetworkEntity::handle_write(const boost::system::error_code& error, const char endOfMessage)
{
    if (stopped_)
        return;
    if (!error)
    {
        //sleep for 500ms to let time for the reciever to process info (had a bug on this one)
        start_read(endOfMessage);
    }
    else
    {
        std::cout << "write error : " << error.message() << "\n";
        stop();
    }
}

void NetworkEntity::start_read(const char endOfMessage)
{
    boost::asio::async_read_until(*socket_, answer_, endOfMessage,
        boost::bind(&NetworkEntity::handle_read, this, boost::asio::placeholders::error));
}

void NetworkEntity::handle_read(const boost::system::error_code& error)
{
    if (stopped_)
        return;
    if (error)
    {
        std::cout << "read error : " << error.message() << "\n";
        stop();
    }
    else
    {
        stop();
    }
}

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

using tcp = boost::asio::ip::tcp;

struct NetworkEntity {

    boost::asio::io_service io_service;
    boost::asio::deadline_timer timeout_{io_service};
    std::string address_ = "localhost";
    std::string port_    = "6767";
    int TIMEOUT_         = 3;
    boost::shared_ptr<tcp::socket> socket_;
    boost::asio::streambuf request_, answer_;

    void stop()
    {
        if (socket_)
        {
            socket_->cancel();
            socket_->close();
        }
        timeout_.cancel();
        io_service.stop();
    }

    void check_timeout(const boost::system::error_code& error)
    {
        if (error != boost::asio::error::operation_aborted)
        {
            stop();
            std::cout << address_ << " timed out\n";
        }
        timeout_.async_wait(boost::bind(&NetworkEntity::check_timeout, this, boost::asio::placeholders::error));
    }

    std::vector<std::string> tcpPoll(const char* message, const char endOfMessage)
    {
        timeout_.expires_from_now(boost::posix_time::seconds(TIMEOUT_));
        timeout_.async_wait(boost::bind(&NetworkEntity::check_timeout, this, boost::asio::placeholders::error));

        tcp::resolver resolver(io_service);
        start_connect(&io_service, resolver.resolve(tcp::resolver::query(address_, port_)), message, endOfMessage);

        io_service.run();
        //retrieve answer from class
        //return answer
        std::ostringstream oss;
        oss << &answer_;
        return { oss.str() };
    }

    void start_connect(boost::asio::io_service* io_service, tcp::resolver::iterator endpoint_iterator, const std::string message, const char endOfMessage)
    {
        socket_.reset(new tcp::socket(*io_service));
        socket_->async_connect(endpoint_iterator->endpoint(),
                boost::bind(&NetworkEntity::handle_connect, this, io_service, boost::asio::placeholders::error, endpoint_iterator, message, endOfMessage));
    }

    void handle_connect(boost::asio::io_service* io_service,
            const boost::system::error_code& err,
            tcp::resolver::iterator endpoint_iterator,
            const std::string message,
            const char endOfMessage)
    {
        if (err)
        {
            std::cout << "Connect error: " << err.message() << "\n";
            stop();
        }
        else
        {
            start_write(message, endOfMessage);
        }
    }

    void start_write(const std::string message, const char endOfMessage)
    {
        std::ostream request_stream(&request_);
        request_stream << message;
        boost::asio::async_write(*socket_, request_,
                boost::bind(&NetworkEntity::handle_write, this, boost::asio::placeholders::error, endOfMessage));
    }

    void handle_write(const boost::system::error_code& error, const char endOfMessage)
    {
        if (!error)
        {
            //sleep for 500ms to let time for the reciever to process info (had a bug on this one)
            start_read(endOfMessage);
        }
        else
        {
            std::cout << "write error : " << error.message() << "\n";
            stop();
        }
    }

    void start_read(const char endOfMessage)
    {
        boost::asio::async_read_until(*socket_, answer_, endOfMessage,
                boost::bind(&NetworkEntity::handle_read, this, boost::asio::placeholders::error));
    }

    void handle_read(const boost::system::error_code& error)
    {
        if (error)
        {
            std::cout << "read error : " << error.message() << "\n";
        }
        stop();
    }
};

int main()
{
    NetworkEntity ne;
    for (auto& s : ne.tcpPoll("this is my request", '\n'))
    {
        std::cout << "Line: '" << s << "'\n";
    }
}