C / C++ / 系统课时
用定时器队列执行超时任务
用定时器队列执行超时任务
网络事件循环除了等待套接字可读写,还必须在没有 I/O 时按时唤醒执行超时任务。本节实现一个最小定时器队列:用唯一 ID 管理任务、按到期时间排序、支持重复调度,并把最近到期时间转换成事件等待超时。
学习目标
- 设计可取消、可重复执行的定时器对象与唯一标识。
- 用最小堆维护最近到期任务,并理解重复任务的重新入队时机。
- 把最近到期时间换算为事件循环的等待时长,避免定时器被 I/O 等待阻塞。
定时器队列需要解决什么
事件循环若始终使用无限等待,哪怕已经有定时任务到期,只要没有新的网络事件,线程也不会被唤醒。正确做法是让 I/O 等待时间同时受定时器约束:等待时间不得超过“当前时间到最近定时器到期时间”的差值。
定时器对象至少需要包含唯一 ID、到期时间、重复间隔和回调。排序只关心到期时间;取消则通过 ID 标识具体任务。重复任务执行完成后,根据间隔计算新的到期时间,再重新放回队列。

用最小堆维护到期顺序
下面的完整示例使用 std::priority_queue 构造最小堆。为避免依赖真实时间,示例用整数毫秒模拟时钟,这样可以稳定观察一次性任务与重复任务的执行顺序。
#include <algorithm>
#include <cstdint>
#include <functional>
#include <iostream>
#include <queue>
#include <unordered_set>
#include <utility>
#include <vector>
using TimerId = std::uint64_t;
struct Timer {
TimerId id;
std::int64_t expireAtMs;
std::int64_t intervalMs;
std::function<void()> callback;
};
struct Earlier {
bool operator()(const Timer& a, const Timer& b) const {
return a.expireAtMs > b.expireAtMs;
}
};
class TimerQueue {
public:
TimerId add(std::int64_t nowMs,
std::int64_t delayMs,
std::int64_t intervalMs,
std::function<void()> callback) {
const TimerId id = ++nextId_;
timers_.push(Timer{id, nowMs + delayMs, intervalMs, std::move(callback)});
return id;
}
void cancel(TimerId id) {
cancelled_.insert(id);
}
std::int64_t nextTimeoutMs(std::int64_t nowMs, std::int64_t maxWaitMs) {
discardCancelledTop();
if (timers_.empty()) {
return maxWaitMs;
}
const auto delta = timers_.top().expireAtMs - nowMs;
return delta <= 0 ? 0 : std::min(delta, maxWaitMs);
}
void runExpired(std::int64_t nowMs) {
discardCancelledTop();
while (!timers_.empty() && timers_.top().expireAtMs <= nowMs) {
Timer timer = timers_.top();
timers_.pop();
if (cancelled_.erase(timer.id) > 0) {
continue;
}
timer.callback();
// 重复任务按“本次到期点 + 周期”推进,减少长期漂移。
if (timer.intervalMs > 0) {
timer.expireAtMs += timer.intervalMs;
timers_.push(std::move(timer));
}
discardCancelledTop();
}
}
private:
void discardCancelledTop() {
while (!timers_.empty() && cancelled_.count(timers_.top().id) > 0) {
cancelled_.erase(timers_.top().id);
timers_.pop();
}
}
TimerId nextId_ = 0;
std::priority_queue<Timer, std::vector<Timer>, Earlier> timers_;
std::unordered_set<TimerId> cancelled_;
};
int main() {
TimerQueue queue;
std::int64_t now = 0;
queue.add(now, 120, 0, [] { std::cout << "once@120\n"; });
const TimerId repeated = queue.add(now, 50, 50, [] {
std::cout << "repeat\n";
});
for (int round = 0; round < 4; ++round) {
const auto wait = queue.nextTimeoutMs(now, 1000);
std::cout << "wait=" << wait << "ms\n";
// 用“等待时长”推进模拟时钟,等价于 poll/epoll_wait 超时返回。
now += wait;
queue.runExpired(now);
if (now >= 100) {
queue.cancel(repeated);
}
}
}预期输出:
wait=50ms
repeat
wait=50ms
repeat
wait=20ms
once@120
wait=1000ms最后一次等待回到 1000ms,说明队列中已经没有有效定时器。真实 Reactor 中这里通常会把该值传给 poll、epoll_wait 或其他 Poller;如果最近任务已经到期,则返回 0,让事件循环立即进入处理阶段。
重复任务与取消的边界
重复任务最容易出现两个错误。其一是用“回调执行结束时刻 + 周期”作为下一次到期时间,回调耗时会不断累积成漂移;若业务更关心固定节拍,应基于原计划到期点推进。其二是直接从堆中删除任意元素,标准优先队列并不擅长这种操作。
示例采用“惰性取消”:取消时只记录 ID,等该定时器到达堆顶再丢弃。这让取消操作保持简单,代价是被取消对象可能暂时留在堆中。若取消量极大,可改用“堆 + 索引表”或分层时间轮。
接入 Reactor 的等待逻辑
实际接入时,事件循环每一轮都应先查询最近到期时间,再把它转换成 Poller 的最大等待时长。等待返回后,处理网络事件并执行已经到期的定时器。这样即使完全没有网络流量,最近定时任务也能准时唤醒循环。
需要特别处理“跨线程新增更早定时器”的情况:如果事件循环已经按旧的较晚到期时间进入阻塞,新任务不能只塞进队列,还要通过 eventfd、管道或框架自身的 wakeup 机制唤醒 Poller,让它重新计算等待时间。
一个稳定的定时器队列并不复杂:最小堆负责“谁最先到期”,唯一 ID 负责“取消谁”,重复间隔负责“何时再次入队”,而最近到期时间则把定时任务真正接进 Reactor 的等待节奏。