定时器（Timer） on Dorkytiger 的小屋

基于优先队列的定时器

Mon, 01 Jan 0001 00:00:00 +0000

一、核心设计

定时器需要一个线程不断检查：“有哪些定时任务到期了？”

用 std::priority_queue（最小堆），堆顶是最快到期的任务。

struct TimerTask {
    std::chrono::steady_clock::time_point expiry;
    std::function<void()> callback;
    std::shared_ptr<bool> cancelled;  // 用于取消

    bool operator>(const TimerTask& other) const {
        return expiry > other.expiry;  // 小顶堆：最早到期的在堆顶
    }
};

class Timer {
    std::priority_queue<TimerTask, std::vector<TimerTask>, std::greater<>> tasks_;
    std::mutex mtx_;
    std::condition_variable cv_;
    bool stop_ = false;
    std::thread worker_;

public:
    Timer() {
        worker_ = std::thread([this] { worker_loop(); });
    }

    ~Timer() {
        {
            std::lock_guard<std::mutex> lock(mtx_);
            stop_ = true;
        }
        cv_.notify_one();
        worker_.join();
    }

    // 延迟 delay 后执行 callback
    // 返回的 TimerId 可用于取消
    std::shared_ptr<bool> addTimer(std::chrono::milliseconds delay,
                                    std::function<void()> callback) {
        auto cancelled = std::make_shared<bool>(false);
        TimerTask task{
            std::chrono::steady_clock::now() + delay,
            std::move(callback),
            cancelled
        };

        {
            std::lock_guard<std::mutex> lock(mtx_);
            tasks_.push(std::move(task));
        }
        cv_.notify_one();  // 唤醒定时线程，重新检查堆顶

        return cancelled;
    }

private:
    void worker_loop() {
        while (!stop_) {
            std::unique_lock<std::mutex> lock(mtx_);

            if (tasks_.empty()) {
                cv_.wait(lock, [this] { return stop_ || !tasks_.empty(); });
                continue;
            }

            auto now = std::chrono::steady_clock::now();
            auto& top = tasks_.top();

            if (now >= top.expiry) {
                // 到期
                auto task = std::move(tasks_.top());
                tasks_.pop();
                lock.unlock();  // 执行回调前解锁

                if (!*task.cancelled) {
                    task.callback();
                }
            } else {
                // 没到期，等待到最早到期的时刻
                cv_.wait_until(lock, top.expiry);
            }
        }
    }
};

二、关键点

主要数据结构：最小堆（priority_queue）
堆顶：最快到期的定时任务

线程循环：
   1. 检查堆顶是否到期 → 到期就执行并弹出
   2. 没到期就 wait_until 到到期时刻（精确定时）
   3. 有新任务加入时 notify 唤醒，重新检查

时间复杂度：

时间轮（Timing Wheel）

Mon, 01 Jan 0001 00:00:00 +0000

一、优先队列定时器的瓶颈在哪？

如果你的系统有百万级定时器（比如网络服务器有 100 万个连接，每个连接保活定时器 60s），优先队列的 $O(\log N)$ 插入可能成为瓶颈。

时间轮把插入降到 $O(1)$。

二、简单时间轮

一个简单的单层时间轮（假设精度 1 秒，共 8 个槽）：

槽 0: [任务A(8s后)]  ← 指针 current
槽 1: []
槽 2: [任务B(2s后)]
槽 3: []
槽 4: []
槽 5: [任务C(5s后)]
槽 6: []
槽 7: []

指针每秒转动一格：
  current=0 → 执行槽0里的任务
  current=1 → 执行槽1里的任务
  ...

插入任务时：计算 expiry = now + delay
槽位 = (current + delay) % 8
直接放入对应槽 → O(1)

三、分层时间轮

单层时间轮的槽数 = 最大延迟。如果需要 1 小时半的定时器，单层需要 3600 个槽。分层时间轮用多层来解决：

取消定时器

Mon, 01 Jan 0001 00:00:00 +0000

为什么要用 shared_ptr<bool> 而不是直接删除任务？

// 取消方式
auto timer_id = timer.addTimer(100ms, [] { ... });
// 取消：标记为已取消
*timer_id = true;

为什么不能直接从优先队列删除？

std::priority_queue 不提供按值删除的接口。
即使可以，删除后要调整堆，$O(\log N)$。

惰性删除：标记任务为取消（*cancelled = true），到期检查时看到已取消就不执行。虽然任务还在队列里占空间，但避免了删除的开销。如果取消的任务不多，这完全可以接受。