C / C++ / 系统课时

实现调用超时与主动取消

实现调用超时与主动取消

并发 RPC 不能只等“正常响应”。调用可能超过截止时间,也可能被业务方主动取消;这两种情况都必须及时从待完成表移除上下文,并让迟到响应安全失效。实现重点是把响应、超时和取消设计成互斥的完成路径。

学习目标

  • 为未完成 RPC 绑定截止时间并在超时时结束等待
  • 实现主动取消并保证调用上下文只完成一次
  • 安全忽略超时或取消后到达的迟到响应

三条完成路径只能赢一条

一个待完成调用通常处于 PENDING 状态,之后可能被正常响应、超时回调或取消操作中的任意一个抢先结束。真正需要保护的不是某个布尔标记,而是“谁拥有完成这个调用的资格”。

最实用的做法是把“从 pending 表删除成功”定义为获胜条件:响应线程删到了上下文,就设置正常结果;定时器删到了上下文,就设置超时异常;取消线程删到了上下文,就设置取消异常。其他路径再次查找时已经找不到该 ID,只需忽略。

RPC 调用从等待到完成、超时和取消的状态迁移

这套规则能把竞态压缩成一次原子意义上的“摘除上下文”。后续的 Promise 完成动作可以放到锁外执行,避免在持锁状态下触发用户回调或异常传播。

实现超时与取消

下面示例使用 std::promise/std::future 表示调用结果。超时线程模拟定时器到期,cancel 模拟业务方主动取消,两个迟到响应最终都会因为上下文已被删除而被忽略。

cpp
#include <atomic>
#include <chrono>
#include <exception>
#include <future>
#include <iostream>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <string>
#include <thread>
#include <unordered_map>
#include <utility>

class RpcClient {
public:
    struct Call {
        uint64_t requestId;
        std::future<std::string> future;
    };

    Call startCall() {
        const uint64_t id = nextId_.fetch_add(1, std::memory_order_relaxed);
        std::promise<std::string> promise;
        auto future = promise.get_future();

        {
            std::lock_guard<std::mutex> lock(mu_);
            pending_.emplace(id, std::move(promise));
        }
        return {id, std::move(future)};
    }

    bool onResponse(uint64_t id, std::string payload) {
        auto promise = take(id);
        if (!promise) {
            return false;
        }
        promise->set_value(std::move(payload));
        return true;
    }

    bool onTimeout(uint64_t id) {
        return fail(id, "rpc timeout");
    }

    bool cancel(uint64_t id) {
        return fail(id, "rpc cancelled");
    }

private:
    std::optional<std::promise<std::string>> take(uint64_t id) {
        std::lock_guard<std::mutex> lock(mu_);
        auto it = pending_.find(id);
        if (it == pending_.end()) {
            return std::nullopt;
        }

        // erase 成功代表当前路径赢得唯一一次完成权。
        std::promise<std::string> promise = std::move(it->second);
        pending_.erase(it);
        return promise;
    }

    bool fail(uint64_t id, const char* message) {
        auto promise = take(id);
        if (!promise) {
            return false;
        }
        promise->set_exception(
            std::make_exception_ptr(std::runtime_error(message)));
        return true;
    }

    std::atomic<uint64_t> nextId_{1};
    std::mutex mu_;
    std::unordered_map<uint64_t, std::promise<std::string>> pending_;
};

std::string resultOf(std::future<std::string>& future) {
    try {
        return future.get();
    } catch (const std::exception& e) {
        return e.what();
    }
}

int main() {
    using namespace std::chrono_literals;

    RpcClient client;
    auto slow = client.startCall();
    auto cancelled = client.startCall();

    std::thread timer([&client, id = slow.requestId] {
        std::this_thread::sleep_for(60ms);
        client.onTimeout(id);
    });

    client.cancel(cancelled.requestId);

    timer.join();

    // 模拟服务端稍后才返回,此时两个上下文都已经被清理。
    const bool slowAccepted = client.onResponse(slow.requestId, "late-slow");
    const bool cancelAccepted =
        client.onResponse(cancelled.requestId, "late-cancel");

    std::cout << "slow=" << resultOf(slow.future) << "\n";
    std::cout << "cancelled=" << resultOf(cancelled.future) << "\n";
    std::cout << "late accepted=" << (slowAccepted + cancelAccepted) << "\n";
}

预期输出:

text
slow=rpc timeout
cancelled=rpc cancelled
late accepted=0

在真实 Reactor 网络库中,不应为每个 RPC 创建一个线程。更常见的是把截止时间注册到时间轮、最小堆或事件循环自带的 TimerQueue,定时器触发时只携带 requestId 回来执行 onTimeout。核心竞争规则与示例完全相同。

定时器也要被正确清理

正常响应先到时,除了从待完成表删除上下文,还应取消或失效对应定时器。否则定时器稍后仍会回调。即使超时函数能因为找不到 ID 而安全返回,多余回调仍会增加事件循环负担。

工程上可以在调用上下文中保存 timer token;响应或取消成功后撤销它。如果底层定时器不支持严格取消,则让回调只拿 requestId,再次查询 pending 表,不要持有已经释放对象的裸指针。

取消是否要通知服务端

本地取消首先解决“调用方不再等待”的问题。是否额外发送 CANCEL(requestId) 给服务端取决于协议设计:如果服务端任务昂贵且可中断,发送取消帧可以释放计算资源;如果任务很快结束或服务端不支持中断,本地清理已经足够保证客户端正确性。

无论是否通知服务端,客户端都不能让取消后的迟到响应重新复活调用。响应路径查不到 requestId 时应安静丢弃,必要时只记录低级别诊断日志。

验证竞态是否安全

测试时应主动覆盖“响应与超时几乎同时发生”“取消与响应同时发生”“超时后收到重复响应”这些情况。正确结果不是要求某一方固定获胜,而是要求恰好一条路径完成 Promise,待完成表最终不残留上下文,也不会出现 double set、悬空引用或二次回调。

当正常响应、超时和取消都通过同一个摘除操作争夺完成权时,RPC 生命周期就有了稳定边界;这比在三个路径里分别维护状态标记更容易证明正确,也更适合继续扩展重试、连接断开与链路取消。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

实现调用超时与主动取消

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通