C / C++ / 系统课时
实现调用超时与主动取消
实现调用超时与主动取消
并发 RPC 不能只等“正常响应”。调用可能超过截止时间,也可能被业务方主动取消;这两种情况都必须及时从待完成表移除上下文,并让迟到响应安全失效。实现重点是把响应、超时和取消设计成互斥的完成路径。
学习目标
- 为未完成 RPC 绑定截止时间并在超时时结束等待
- 实现主动取消并保证调用上下文只完成一次
- 安全忽略超时或取消后到达的迟到响应
三条完成路径只能赢一条
一个待完成调用通常处于 PENDING 状态,之后可能被正常响应、超时回调或取消操作中的任意一个抢先结束。真正需要保护的不是某个布尔标记,而是“谁拥有完成这个调用的资格”。
最实用的做法是把“从 pending 表删除成功”定义为获胜条件:响应线程删到了上下文,就设置正常结果;定时器删到了上下文,就设置超时异常;取消线程删到了上下文,就设置取消异常。其他路径再次查找时已经找不到该 ID,只需忽略。

这套规则能把竞态压缩成一次原子意义上的“摘除上下文”。后续的 Promise 完成动作可以放到锁外执行,避免在持锁状态下触发用户回调或异常传播。
实现超时与取消
下面示例使用 std::promise/std::future 表示调用结果。超时线程模拟定时器到期,cancel 模拟业务方主动取消,两个迟到响应最终都会因为上下文已被删除而被忽略。
#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";
}预期输出:
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 生命周期就有了稳定边界;这比在三个路径里分别维护状态标记更容易证明正确,也更适合继续扩展重试、连接断开与链路取消。