Question

我尝试使用async_receive_from方法来获取数据。但是当我开始时，程序不会等待超时或正在读取某些内容。我知道数据是在端口上传入的（wireshark）。可能是什么原因。我尝试使用boost website中的不同示例。当我调试代码时，我总是得到错误代码125（operation_aborted）。这是我的代码的相关部分：

UDPCommunication::UDPCommunication(){
    m_portReceive = 2041;
    m_byteArrayLen = 0;
    m_lengthReceive = 0;
    m_dataReceived = false;
}

void UDPCommunication::openSocketReceive(){
    try{
        m_socketReceive = shared_ptr<udp::socket>(
                new udp::socket(m_ioService,
                        udp::endpoint(udp::v4(), m_portReceive)));

        m_receiveTimeout = shared_ptr<boost::asio::deadline_timer>(
                new boost::asio::deadline_timer(m_ioService));

        m_receiveTimeout->async_wait(
                boost::bind(&UDPCommunication::udpReceiveTimeoutHandler, this,
                        boost::asio::placeholders::error, 0));

        m_dataReceived = false;

    } catch(std::exception& e){
        std::cerr << e.what() << std::endl;
        ErrorLogging::log(e);
    }
}

void UDPCommunication::udpReceiveWithTimeout(long time){    
    try{
        boost::system::error_code ec;
        m_receiveTimeout->expires_from_now(boost::posix_time::seconds(time));
        ec = boost::asio::error::would_block;
        m_lengthReceive = 0;
        m_socketReceive->async_receive_from(buffer(m_bufferReceive),
                m_endpointReceive,
                boost::bind(&UDPCommunication::udpReceiveTimeoutHandler, this,
                        boost::asio::placeholders::error,
                        boost::asio::placeholders::bytes_transferred));
        do{
            m_ioService.run_one();
        }while(ec == boost::asio::error::would_block);

    } catch(std::exception& e){
        std::cerr << e.what() << std::endl;
        ErrorLogging::log(e);
    }   
}

bool UDPCommunication::udpReceiveTimeoutHandler(
        const boost::system::error_code& ec, size_t size){
    try{
        m_socketReceive->cancel();
        m_receiveTimeout->cancel();
        if(ec != boost::asio::error::would_block){

            m_dataReceived = false;
            return false;
        }else{
            m_lengthReceive = sizeof(m_bufferReceive);
            m_vectorBuffer.resize(m_lengthReceive);
            int i = 0;
            for(std::vector<unsigned char>::iterator it =
                    m_vectorBuffer.begin(); it != m_vectorBuffer.end(); ++it){
                *it = m_bufferReceive[i];
                ++i;
            }
            m_dataReceived = true;
            return true;
        }
    } catch(std::exception& e){
        std::cerr << e.what() << std::endl;
        ErrorLogging::log(e);
        return false;
    }
    return false;
}

bool UDPCommunication::dataReceived(){
    return m_dataReceived;
}

void main(){
    udpCommunication = shared_ptr<UDPCommunication>(new UDPCommunication());
    udpCommunication->openSocketReceive();
    udpCommunication->udpReceiveWithTimeout(5);
    bool dataReceived = udpCommunication->dataReceived();

    std::cout<< dataReceived << std::endl; //is data coming?
}

上部问题的解决方案。本守则工作正常：

int m_portReceive;
int m_byteArrayLen;
io_service m_ioService;
udp::endpoint m_endpointReceive;
shared_ptr<udp::socket> m_socketReceive;
shared_ptr<boost::asio::deadline_timer> m_receiveTimeout;
std::vector<unsigned char> m_vectorBuffer;
unsigned char m_bufferReceive[128];
size_t m_lengthReceive;
bool m_dataReceived;
bool m_timeoutFired;
boost::mutex m_mutex;

UDPCommunication::UDPCommunication(){
    m_portReceive = 2041;
    m_byteArrayLen = 0;
    m_lengthReceive = 0;
    m_dataReceived = false;
    m_timeoutFired = false;
}

void UDPCommunication::openSocketReceive(){
    try{
        m_socketReceive = shared_ptr<udp::socket>(
                new udp::socket(m_ioService,
                        udp::endpoint(udp::v4(), m_portReceive)));

        m_receiveTimeout = shared_ptr<boost::asio::deadline_timer>(
                new boost::asio::deadline_timer(m_ioService));

        m_receiveTimeout->expires_at(boost::posix_time::pos_infin);
        UDPCommunication::udpTimeoutHandler();

        m_receiveTimeout->async_wait(
                boost::bind(&UDPCommunication::udpTimeoutHandler, this));

        m_dataReceived = false;

    } catch(std::exception& e){
        std::cerr << e.what() << std::endl;
        ErrorLogging::log(e);
    }
}

void UDPCommunication::udpReceiveWithTimeout(long time){

    try{
        boost::system::error_code ec;
        m_receiveTimeout->expires_from_now(
                boost::posix_time::time_duration(
                        boost::posix_time::seconds(time)));

        m_socketReceive->async_receive_from(buffer(m_bufferReceive),
                m_endpointReceive,
                boost::bind(&UDPCommunication::udpReceiveHandler, this,
                        boost::asio::placeholders::error,
                        boost::asio::placeholders::bytes_transferred));
        do{
            m_ioService.run_one();
        }while((m_lengthReceive == 0)
                && (m_timeoutFired == false));

    } catch(std::exception& e){
        std::cerr << e.what() << std::endl;
        ErrorLogging::log(e);
    }
}

void UDPCommunication::udpReceiveHandler(const boost::system::error_code& ec,
        size_t size){
    try{
        m_mutex.lock();
        if(m_timeoutFired == false){
            if(size > 0){
                m_socketReceive->cancel();
                m_receiveTimeout->cancel();
                m_lengthReceive = size;

                m_vectorBuffer.resize(m_lengthReceive);
                int i = 0;
                for(std::vector<unsigned char>::iterator it =
                        m_vectorBuffer.begin(); it != m_vectorBuffer.end();
                        ++it){
                    *it = m_bufferReceive[i];
                    ++i;
                }

                m_dataReceived = true;
            }else{
                m_lengthReceive = 0;
                m_socketReceive->async_receive_from(buffer(m_bufferReceive),
                        m_endpointReceive,
                        boost::bind(&UDPCommunication::udpReceiveHandler, this,
                                boost::asio::placeholders::error,
                                boost::asio::placeholders::bytes_transferred));
            }
        }
        m_mutex.unlock();
    } catch(std::exception& e){
        std::cerr << e.what() << std::endl;
        ErrorLogging::log(e);
        m_mutex.unlock();
    }
}


    void UDPCommunication::udpTimeoutHandler(){
    try{
        m_mutex.lock();
        if(m_lengthReceive == 0){
            if(m_receiveTimeout->expires_at()
                    <= deadline_timer::traits_type::now()){
                std::cout << "timeout: no data received from modem"
                        << std::endl;
                m_socketReceive->cancel();
                m_dataReceived = false;
                m_receiveTimeout->expires_at(boost::posix_time::pos_infin);
                m_timeoutFired = true;
            }
            m_receiveTimeout->async_wait(
                    boost::bind(&UDPCommunication::udpTimeoutHandler, this));
        }
        m_mutex.unlock();
    } catch(std::exception& e){
        std::cerr << e.what() << std::endl;
        ErrorLogging::log(e);
        m_mutex.unlock();
    }
}

bool UDPCommunication::dataReceived(){
    return m_dataReceived;
}

void main(){
    udpCommunication = shared_ptr<UDPCommunication>(new UDPCommunication());
    udpCommunication->openSocketReceive();
    udpCommunication->udpReceiveWithTimeout(5);
    bool dataReceived = udpCommunication->dataReceived();

    std::cout<< dataReceived << std::endl; //is data coming?

    //now do something with data...
}

Answer 1

请注意，我没有检查每一行是否有其他错误，但有两个问题浮现在脑海中：

你的deadline_timer上的async_wait没有先设置到期时间。
您使用io_service.run_one（）而不在其间调用io_service.reset（）。

我不确定第一个是什么，但第二个意思是，一旦run_one（）第一次返回（通过发布任何处理程序或通过停止），它将立即返回每次再次调用时，没有做好自己的工作。

第一个可能会使用operation_aborted调用你的超时处理程序，第二个点可能会让你的io_service不再执行任何操作。

编辑：

    do{
        m_ioService.run_one();
    }while(ec == boost::asio::error::would_block);

如果你想让run_one（）方法改变ec，你必须像这样传递它：run_one（ec）因此，ec是该方法中的局部变量，不应该被任何东西修改，因此始终保持will_block。当然，在这种情况下，run_one将不再抛出任何东西，而是将其结果存储在ec。

Boost UDP async_receive_from不等待超时或接收

1 个答案: