Boost定时器未超作用域却立即超时的RS485通信问题

我正在开发一个RS485通信类，想要实现一个带超时机制、读取到指定字符为止的函数。但目前遇到一个问题：无论设置多长的超时时间，系统定时器都会立即返回超时。我试过把定时器改成类的成员变量来避免作用域问题，没用；也换过不同的定时器实现（主要是deadline_timer），同样无效。如果移除定时器代码，读取操作能成功，但只要加了定时器，哪怕设10秒超时（显然足够长），也会立刻触发超时。

下面是该类的简化版本：

class RS485CommunicationLayer final {
public:
    RS485CommunicationLayer(
            const std::string& path,
            /* options */
    ): io(), port(io), timer(port.get_io_service()) {
        open(/* options */);
    };

    std::size_t write(const char* const buffer, const size_t size) {
        /*impl*/
    }
// 目标函数 --v
    void readUntil(std::vector<char>& buffer, char delim,std::chrono::microseconds timeout) {
        boost::optional<boost::system::error_code> timer_result;
        boost::optional<boost::system::error_code> read_result;
        
        port.get_io_service().reset();
        
        timer.expires_from_now(timeout);
        boost::asio::async_read_until(port,  asio::dynamic_buffer(buffer), delim, [&read_result] (const boost::system::error_code& error, size_t) { read_result.reset(error); });
        timer.async_wait([&timer_result] (const boost::system::error_code& error) { timer_result.reset(error); });
    
        
        while (port.get_io_service().run_one())
        { 
            if (read_result)
                timer.cancel();
            else if (timer_result) {
                port.cancel();
            }
        }
    
        if (read_result)
            throw boost::system::system_error(*read_result);
    };

private:
    asio::io_context io;
    asio::serial_port port;
    boost::asio::system_timer timer;

    void open(/*args*/) {
       port.open(path);
       /*set options*/
    }
};

编辑补充：
后来了解到run_for()方法，我尝试了以下实现，但缓冲区始终为空：

void RS485CommunicationLayer::readUntil(std::vector<char>& buffer, char delim, std::chrono::microseconds timeout) {
    boost::optional<boost::system::error_code> read_result;
    
    boost::asio::async_read_until(port,  asio::dynamic_buffer(buffer), delim, [&read_result] (const boost::system::error_code& error, size_t) { read_result.reset(error); });

    port.get_io_service().run_for(timeout);
    if (read_result)
        throw boost::system::system_error(*read_result);
}

第一个实现的问题分析与修复 #

问题根源 #

1. 定时器状态未清理：类成员的system_timer可能残留之前的异步等待操作，直接调用expires_from_now不会清除旧的超时事件，导致一运行就触发旧的超时回调。
2. io_context::reset()误用：重置io_context前未清理残留的异步操作，可能导致后续执行逻辑异常。
3. 未区分取消与真正超时：读取完成后取消定时器，回调会收到operation_aborted错误，代码未区分该错误和实际超时，误判为超时。

修复代码 #

void readUntil(std::vector<char>& buffer, char delim, std::chrono::microseconds timeout) {
    boost::optional<boost::system::error_code> timer_result;
    boost::optional<boost::system::error_code> read_result;
    
    // 先清空定时器的所有异步操作，确保初始状态干净
    timer.cancel();
    // 重置io_context前清理残留操作
    io.reset();

    timer.expires_from_now(timeout);
    boost::asio::async_read_until(port, asio::dynamic_buffer(buffer), delim, 
        [&read_result](const boost::system::error_code& error, size_t) {
            read_result.reset(error);
        });
    timer.async_wait([&timer_result](const boost::system::error_code& error) {
        // 忽略主动取消的错误，只记录真正的超时
        if (error != boost::asio::error::operation_aborted) {
            timer_result.reset(error);
        }
    });

    while (io.run_one()) {
        if (read_result) {
            timer.cancel();
        } else if (timer_result) {
            port.cancel();
        }
    }

    // 处理读取结果：如果是超时导致的取消，抛出超时异常
    if (read_result) {
        if (*read_result == boost::asio::error::operation_aborted) {
            throw boost::system::system_error(boost::asio::error::timed_out);
        }
        throw boost::system::system_error(*read_result);
    }
}

第二个run_for()实现的问题分析与修复 #

问题根源 #

1. 未处理超时后的读取操作：run_for()超时返回后，异步读取可能仍在进行，未主动取消会导致后续调用受残留操作影响，且缓冲区不会被填充。
2. 未判断超时场景：超时后read_result不会被赋值，代码未处理这种情况，既不抛出异常也不提示超时。
3. io_context状态未重置：多次调用会累积未处理操作，导致逻辑混乱。

修复代码 #

void readUntil(std::vector<char>& buffer, char delim, std::chrono::microseconds timeout) {
    boost::optional<boost::system::error_code> read_result;
    
    // 重置io_context，清理之前的残留操作
    io.reset();

    boost::asio::async_read_until(port, asio::dynamic_buffer(buffer), delim, 
        [&read_result](const boost::system::error_code& error, size_t) {
            read_result.reset(error);
        });

    // 运行io_context指定时长
    io.run_for(timeout);

    // 如果读取未完成，主动取消并处理回调
    if (!read_result) {
        port.cancel();
        // 处理取消后的回调，确保read_result被赋值
        io.run_one();
        // 将取消错误转为超时异常抛出
        throw boost::system::system_error(boost::asio::error::timed_out);
    }

    // 处理其他读取错误
    if (*read_result) {
        throw boost::system::system_error(*read_result);
    }
}

额外注意事项 #

• 确保串口配置（波特率、奇偶校验、停止位等）完全匹配设备要求，错误配置会导致读取异常。
• 每次调用异步操作前，必须清理定时器和io_context的残留状态，避免旧操作干扰新逻辑。
• operation_aborted错误不一定是失败：读取完成后取消定时器也会触发该错误，需根据场景判断是否抛出异常。

内容的提问来源于stack exchange，提问作者Typhaon