C / C++ / 系统课时

用定时器队列执行超时任务

用定时器队列执行超时任务

网络事件循环除了等待套接字可读写,还必须在没有 I/O 时按时唤醒执行超时任务。本节实现一个最小定时器队列:用唯一 ID 管理任务、按到期时间排序、支持重复调度,并把最近到期时间转换成事件等待超时。

学习目标

  • 设计可取消、可重复执行的定时器对象与唯一标识。
  • 用最小堆维护最近到期任务,并理解重复任务的重新入队时机。
  • 把最近到期时间换算为事件循环的等待时长,避免定时器被 I/O 等待阻塞。

定时器队列需要解决什么

事件循环若始终使用无限等待,哪怕已经有定时任务到期,只要没有新的网络事件,线程也不会被唤醒。正确做法是让 I/O 等待时间同时受定时器约束:等待时间不得超过“当前时间到最近定时器到期时间”的差值。

定时器对象至少需要包含唯一 ID、到期时间、重复间隔和回调。排序只关心到期时间;取消则通过 ID 标识具体任务。重复任务执行完成后,根据间隔计算新的到期时间,再重新放回队列。

定时器队列与事件循环协作流程

用最小堆维护到期顺序

下面的完整示例使用 std::priority_queue 构造最小堆。为避免依赖真实时间,示例用整数毫秒模拟时钟,这样可以稳定观察一次性任务与重复任务的执行顺序。

cpp
#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);
        }
    }
}

预期输出:

text
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 的等待节奏。

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

目录与阅读设置

阅读设置

17

记录一个想法

用定时器队列执行超时任务

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

登录哪都通