海量定时任务的优雅解法：时间轮算法原理与 Go 语言实现

一、定时任务的常见做法及其瓶颈

在后端开发中，定时任务无处不在：订单超时自动取消、缓存过期清理、心跳检测、失败重试。最直观的做法是为每个任务创建一个计时器（比如 Go 里的 time.AfterFunc），或者用一个最小堆维护所有任务的触发时间。

任务量不大时，这两种做法都工作得很好。但当任务规模涨到十万、百万级别，问题就暴露出来了：

1. 海量计时器：每个任务一个 time.Timer，意味着同样数量的底层计时器资源，内存和调度开销随任务数线性增长；
2. 最小堆方案：插入、删除的时间复杂度是 O(log n)，高频插入场景下堆调整成为热点，还需要加锁保护，锁争用严重。

我们需要一种插入、删除接近 O(1)，内存占用又可控的结构——这就是时间轮（Timing Wheel）。

二、时间轮的核心原理

时间轮的思想借鉴了钟表：把时间轴切成固定数量的槽位（slot），组成一个环形数组；每个槽位对应一个时间刻度（tick），指针每 tick 前进一步。

• 任务挂载：每个槽位维护一个任务链表。添加延迟为 d 的任务时，计算它该落到哪个槽位：slot = (current + d / tick) % slotNum，同时记录它还需要转多少圈（round）；
• 指针推进：每 tick 推进一格，检查当前槽位上的任务：round 为 0 就执行，否则 round 减 1；
• 时间复杂度：添加、取消任务都是 O(1)；每个 tick 只扫描一个槽位，开销恒定。

单层时间轮能表达的最大延迟受 slotNum × tick 限制。Netty 的 HashedWheelTimer 用单层大轮（如 512 槽）配合 round 计数，简单高效；Kafka 则使用分层时间轮：秒级、分钟级、小时级层层嵌套，低层转满一圈就推进高层一格，兼顾精度与表达范围。

三、Go 语言实现一个单层时间轮

下面用不到 100 行代码实现一个线程安全的时间轮：

package main

import (
	"container/list"
	"sync"
	"time"
)

type task struct {
	round int    // 还需经过的圈数
	fn    func() // 到期执行的函数
}

type TimingWheel struct {
	mu     sync.Mutex
	tick   time.Duration
	slots  []*list.List
	cur    int
	stopCh chan struct{}
}

func NewTimingWheel(tick time.Duration, slotNum int) *TimingWheel {
	tw := &TimingWheel{
		tick:   tick,
		slots:  make([]*list.List, slotNum),
		stopCh: make(chan struct{}),
	}
	for i := range tw.slots {
		tw.slots[i] = list.New()
	}
	return tw
}

// Add 在延迟 d 后执行 fn，返回任务节点（可用于取消）
func (tw *TimingWheel) Add(d time.Duration, fn func()) *list.Element {
	tw.mu.Lock()
	defer tw.mu.Unlock()
	ticks := int(d / tw.tick)
	slot := (tw.cur + ticks) % len(tw.slots)
	t := &task{round: ticks / len(tw.slots), fn: fn}
	return tw.slots[slot].PushBack(t)
}

// Cancel 取消任务，需传入任务所在槽位与节点
func (tw *TimingWheel) Cancel(slot int, e *list.Element) {
	tw.mu.Lock()
	defer tw.mu.Unlock()
	tw.slots[slot].Remove(e)
}

func (tw *TimingWheel) Start() {
	ticker := time.NewTicker(tw.tick)
	go func() {
		for {
			select {
			case <-ticker.C:
				tw.advance()
			case <-tw.stopCh:
				ticker.Stop()
				return
			}
		}
	}()
}

func (tw *TimingWheel) advance() {
	tw.mu.Lock()
	defer tw.mu.Unlock()
	tw.cur = (tw.cur + 1) % len(tw.slots)
	l := tw.slots[tw.cur]
	for e := l.Front(); e != nil; {
		next := e.Next()
		t := e.Value.(*task)
		if t.round > 0 {
			t.round--
		} else {
			l.Remove(e)
			go t.fn() // 异步执行，避免阻塞指针推进
		}
		e = next
	}
}

使用示例：

func main() {
	tw := NewTimingWheel(100*time.Millisecond, 512)
	tw.Start()
	tw.Add(5*time.Second, func() {
		println("5 秒后触发：订单超时，自动取消")
	})
	select {}
}

四、工程调参的三个关键点

1. tick 的选择：tick 越小精度越高，但空转扫描越频繁。取业务能接受的最大延迟误差即可，如 100ms～1s；
2. 槽位数量：槽位越多，单个槽位的任务越少，单次扫描越快，但内存占用越大，512 或 1024 是常见取值；
3. 任务分级：延迟差异大的任务分层处理——秒级任务走小 tick 轮，小时级任务走大 tick 轮，避免“大炮打蚊子”。

五、适用场景与局限

时间轮适合海量、延迟精度要求不高的场景：IM 消息超时、分布式锁续期、限流时间窗口、游戏技能冷却。它的局限也很明确：不适合毫秒级精度的场景；进程重启后内存中的任务全部丢失，关键任务仍要配合持久化（比如落库 + 启动扫描补偿）。

结语

时间轮用“空间换时间”的思路，把定时任务的维护成本从 O(log n) 降到 O(1)，是 Netty、Kafka 等中间件的共同选择。下次面对“十万级延迟任务”的需求时，不妨先画一个圈，再让指针转起来。