定时器的实现:从逐帧计时到最小堆与时间轮
一、需求
定时器在游戏中无处不在:
- 延迟执行:3 秒后刷新怪物;
- 重复执行:每秒恢复 1 点体力,每 0.5 秒造成一次持续伤害;
- 倒计时:技能冷却、Buff 持续时间、活动剩余时间;
- 超时:网络请求 10 秒没有响应就重试。
需要支持:添加、取消、暂停;回调中可以再添加新的定时器;数量从几个到成千上万(服务器上更多)。
二、基础做法
| 做法 | 实现 | 问题 |
|---|---|---|
| 各自在 Update 中计时 | 每个对象维护自己的计时变量,每帧减去 deltaTime | 逻辑分散;对象多时 Update 调用本身就有开销(见 减少 Update 的数量) |
| 协程 / 异步 | yield return new WaitForSeconds(3),或 await UniTask.Delay(3000) | 简单方便;取消需要额外处理;大量使用时有分配(见 Unity 异步编程) |
| 统一管理器 + 列表 | 所有定时器放在一个列表中,每帧遍历,到时间的触发 | 集中管理了,但每帧都要检查所有定时器,O(n) |
数量不多(几十个)时,统一管理器 + 列表完全够用。数量很大时,问题在于每帧检查了大量还远没到时间的定时器。下面两种结构正是为了解决这个问题。
三、最小堆
按触发时间把定时器放进最小堆,堆顶永远是最早触发的那个:
每帧: while 堆顶的触发时间 <= 当前时间: 取出堆顶,执行回调 如果是重复定时器,更新触发时间后重新放回堆中- 添加:O(log n);
- 每帧检查:只看堆顶,没到时间就立即结束,不再关心其他定时器;
- 取消:在堆中查找并删除比较麻烦。常用延迟删除:只把定时器标记为已取消,等它到达堆顶时直接丢弃。
public class TimerManager{ class Timer { public double Time; public double Interval; public Action Callback; public bool Cancelled; }
readonly List<Timer> _heap = new(); double _now;
public object Add(double delay, Action callback, double interval = 0) { var t = new Timer { Time = _now + delay, Interval = interval, Callback = callback }; Push(t); return t; // 作为句柄,用于取消 }
public void Cancel(object handle) => ((Timer)handle).Cancelled = true;
public void Update(double deltaTime) { _now += deltaTime; while (_heap.Count > 0 && _heap[0].Time <= _now) { var t = Pop(); if (t.Cancelled) continue; // 延迟删除 t.Callback(); if (t.Interval > 0 && !t.Cancelled) // 重复定时器重新入堆 { t.Time += t.Interval; Push(t); } } }
void Push(Timer t) { _heap.Add(t); int i = _heap.Count - 1; while (i > 0) { int p = (i - 1) / 2; if (_heap[p].Time <= _heap[i].Time) break; (_heap[p], _heap[i]) = (_heap[i], _heap[p]); i = p; } }
Timer Pop() { var top = _heap[0]; int last = _heap.Count - 1; _heap[0] = _heap[last]; _heap.RemoveAt(last); int i = 0; while (true) { int l = i * 2 + 1, r = l + 1, m = i; if (l < _heap.Count && _heap[l].Time < _heap[m].Time) m = l; if (r < _heap.Count && _heap[r].Time < _heap[m].Time) m = r; if (m == i) break; (_heap[m], _heap[i]) = (_heap[i], _heap[m]); i = m; } return top; }}重复定时器用 t.Time += t.Interval 而不是 _now + Interval:这样即使某一帧卡顿导致处理晚了,下一次触发的时间也不会被推后,长期不会产生累积误差。
四、时间轮
原理
时间轮像一个钟表:一个环形数组,每个格子(槽)代表一个时间刻度(比如 100 毫秒),格子里存放在这个时刻到期的定时器。一个指针每过一个刻度前进一格,执行当前格子中的定时器。
槽数 8,刻度 100ms,指针当前在第 2 格
[0] [1] [2] [3] [4] [5] [6] [7] ↑ 指针
添加一个 300ms 后触发的定时器:需要 3 个刻度 → 放进第 (2 + 3) % 8 = 5 格- 添加:直接算出槽的位置,O(1);
- 每个刻度:只处理当前槽中的定时器;
- 非常适合大量定时器、频繁添加和取消的场景,服务器、网络框架中被广泛使用。
超出一圈:轮数
延迟超过一圈(8 格 × 100ms = 800ms)怎么办?给定时器记录一个剩余轮数:
延迟 n 个刻度: 槽位 = (当前指针 + n) % 槽数 轮数 = (n - 1) / 槽数 ← 指针还要经过这个槽多少次之后才真正触发
指针每次经过时:轮数 > 0 就减一跳过,轮数为 0 才触发public class TimingWheel{ class Timer { public int Rounds; public Action Callback; public bool Cancelled; }
readonly List<Timer>[] _slots; readonly double _tick; int _cursor; double _accumulated;
public TimingWheel(int slotCount, double tick) { _slots = new List<Timer>[slotCount]; for (int i = 0; i < slotCount; i++) _slots[i] = new List<Timer>(); _tick = tick; }
public object Add(double delay, Action callback) { int ticks = Math.Max(1, (int)Math.Ceiling(delay / _tick)); var t = new Timer { Rounds = (ticks - 1) / _slots.Length, Callback = callback }; _slots[(_cursor + ticks) % _slots.Length].Add(t); return t; }
public void Cancel(object handle) => ((Timer)handle).Cancelled = true;
public void Update(double deltaTime) { _accumulated += deltaTime; while (_accumulated >= _tick) { _accumulated -= _tick; _cursor = (_cursor + 1) % _slots.Length; var slot = _slots[_cursor]; for (int i = slot.Count - 1; i >= 0; i--) // 倒序遍历,回调中新加入的定时器不会在本轮被处理 { var t = slot[i]; if (t.Cancelled) { slot.RemoveAt(i); continue; } if (t.Rounds > 0) { t.Rounds--; continue; } slot.RemoveAt(i); t.Callback(); } } }}分层时间轮
只有一层时,延迟很长的定时器会在每一圈都被检查一次(只是减少轮数)。分层时间轮像钟表的时、分、秒三根针:
秒轮:60 格,每格 1 秒分轮:60 格,每格 1 分钟时轮:24 格,每格 1 小时
2 小时 5 分钟后触发的定时器 → 先放进时轮时轮转到它所在的格子时 → 把它降级放进分轮的对应位置分轮转到时 → 再降级到秒轮秒轮转到时 → 触发每个定时器在整个生命周期中只会被移动很少的几次。
精度
时间轮的精度就是一个刻度。刻度为 100 毫秒时,定时器最多会晚约 100 毫秒触发。刻度越小越精确,但空转的次数越多。客户端游戏中对精度要求高的定时(技能、Buff),刻度可以和逻辑帧对齐。
五、最小堆与时间轮对比
| 列表 | 最小堆 | 时间轮 | |
|---|---|---|---|
| 添加 | O(1) | O(log n) | O(1) |
| 每帧检查 | O(n) | O(1)(只看堆顶) | 只处理当前槽 |
| 取消 | O(n) 或标记 | 标记,延迟删除 | 标记,或 O(1) 从槽中移除 |
| 精度 | 精确 | 精确 | 一个刻度 |
| 适合 | 数量少 | 客户端中等数量、需要精确时间 | 大量定时器,服务器、网络超时 |
六、时间源与其他注意事项
用哪个时间驱动,决定了定时器在暂停、切后台时的行为:
| 时间源 | 暂停(timeScale = 0)时 | 适合 |
|---|---|---|
Time.deltaTime | 停止 | 战斗中的技能冷却、Buff |
Time.unscaledDeltaTime | 继续 | UI 动画、暂停菜单中的计时 |
| 服务器时间 | 继续,且不受修改手机时间影响 | 体力恢复、活动倒计时(见 倒计时) |
其他注意事项:
- 回调中添加或取消定时器:要确保遍历过程不会因此出错(上面的实现中用了倒序遍历和延迟删除)。
- 回调中的异常:一个回调抛出异常,不应该中断其他定时器的执行,可以在调用回调时捕获异常并记录日志。
- 对象销毁:定时器的回调引用了已经销毁的对象,到时间时就会出错。对象销毁时要取消它创建的定时器,或者在回调中检查对象是否还存在。
- 卡顿后的补偿:一帧卡了很久,重复定时器可能一次需要触发多次。需要根据业务决定是全部补上(持续伤害),还是只触发一次(刷新显示)。
常见追问
大量定时器怎么高效管理? 最小堆:按触发时间排序,每帧只检查堆顶;时间轮:环形数组,添加 O(1),每个刻度只处理当前槽。
时间轮的原理是什么? 环形数组,每格代表一个时间刻度,指针按刻度前进,执行当前格子中的定时器。添加时直接计算出目标槽位,超过一圈的记录剩余轮数。
延迟超过一圈怎么办? 记录轮数,指针经过时轮数减一,为零才触发;或者使用分层时间轮,长延迟的定时器先放在粗粒度的轮中,逐级下放。
最小堆和时间轮怎么选? 需要精确时间、数量中等用最小堆;数量巨大、频繁增删、可以接受一个刻度误差用时间轮。
定时器的取消怎么实现? 标记为已取消,到期时直接丢弃(延迟删除),避免在堆或槽中查找。
重复定时器怎么避免误差累积? 下一次触发时间在上一次的计划时间上加间隔,而不是在当前时间上加。
定时器用哪个时间驱动? 战斗相关用缩放时间,UI 和暂停菜单用真实时间,体力、活动等用服务器时间。
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!