一个系统中存在着大量的调度任务,同时调度任务存在时间的滞后性,而大量的调度任务若是每个都使用本身的调度器来管理任务的生命周期的话,浪费cpu的资源并且很低效。git
本文来介绍 go-zero
中 延迟操做,它可能让开发者调度多个任务时,只需关注具体的业务执行函数和执行时间「当即或者延迟」。而 延迟操做,一般能够采用两个方案:github
Timer
:定时器维护一个优先队列,到时间点执行,而后把须要执行的 task 存储在 map 中collection
中的 timingWheel
,维护一个存听任务组的数组,每个槽都维护一个存储task的双向链表。开始执行时,计时器每隔指定时间执行一个槽里面的tasks。方案2把维护task从 优先队列 O(nlog(n))
降到 双向链表 O(1)
,而执行task也只要轮询一个时间点的tasks O(N)
,不须要像优先队列,放入和删除元素 O(nlog(n))
。数组
咱们先看看 go-zero
中本身对 timingWheel
的使用 :数据结构
首先咱们先来在 collection
的 cache
中关于 timingWheel
的使用:app
timingWheel, err := NewTimingWheel(time.Second, slots, func(k, v interface{}) { key, ok := k.(string) if !ok { return } cache.Del(key) }) if err != nil { return nil, err } cache.timingWheel = timingWheel
这是 cache
初始化中也同时初始化 timingWheel
作key的过时处理,参数依次表明:异步
interval
:时间划分刻度numSlots
:时间槽execute
:时间点执行函数在 cache
中执行函数则是 删除过时key,而这个过时则由 timingWheel
来控制推动时间。函数
接下来,就经过 cache
对 timingWheel
的使用来认识。工具
// 真正作初始化 func newTimingWheelWithClock(interval time.Duration, numSlots int, execute Execute, ticker timex.Ticker) ( *TimingWheel, error) { tw := &TimingWheel{ interval: interval, // 单个时间格时间间隔 ticker: ticker, // 定时器,作时间推进,以interval为单位推动 slots: make([]*list.List, numSlots), // 时间轮 timers: NewSafeMap(), // 存储task{key, value}的map [执行execute所须要的参数] tickedPos: numSlots - 1, // at previous virtual circle execute: execute, // 执行函数 numSlots: numSlots, // 初始化 slots num setChannel: make(chan timingEntry), // 如下几个channel是作task传递的 moveChannel: make(chan baseEntry), removeChannel: make(chan interface{}), drainChannel: make(chan func(key, value interface{})), stopChannel: make(chan lang.PlaceholderType), } // 把 slot 中存储的 list 所有准备好 tw.initSlots() // 开启异步协程,使用 channel 来作task通讯和传递 go tw.run() return tw, nil }
以上比较直观展现 timingWheel
的 “时间轮”,后面会围绕这张图解释其中推动的细节。oop
go tw.run()
开一个协程作时间推进:性能
func (tw *TimingWheel) run() { for { select { // 定时器作时间推进 -> scanAndRunTasks() case <-tw.ticker.Chan(): tw.onTick() // add task 会往 setChannel 输入task case task := <-tw.setChannel: tw.setTask(&task) ... } } }
能够看出,在初始化的时候就开始了 timer
执行,并以internal
时间段转动,而后底层不停的获取来自 slot
中的 list
的task,交给 execute
执行。
紧接着就是设置 cache key
:
func (c *Cache) Set(key string, value interface{}) { c.lock.Lock() _, ok := c.data[key] c.data[key] = value c.lruCache.add(key) c.lock.Unlock() expiry := c.unstableExpiry.AroundDuration(c.expire) if ok { c.timingWheel.MoveTimer(key, expiry) } else { c.timingWheel.SetTimer(key, value, expiry) } }
data map
中有没有存在这个keyexpire
-> MoveTimer()
SetTimer()
因此对于 timingWheel
的使用上就清晰了,开发者根据需求能够 add
或是 update
。
同时咱们跟源码进去会发现:SetTimer() MoveTimer()
都是将task输送到channel,由 run()
中开启的协程不断取出 channel
的task操做。
SetTimer() -> setTask()
:
- not exist task:
getPostion -> pushBack to list -> setPosition
- exist task:
get from timers -> moveTask()
MoveTimer() -> moveTask()
由上面的调用链,有一个都会调用的函数:moveTask()
func (tw *TimingWheel) moveTask(task baseEntry) { // timers: Map => 经过key获取 [positionEntry「pos, task」] val, ok := tw.timers.Get(task.key) if !ok { return } timer := val.(*positionEntry) // {delay < interval} => 延迟时间比一个时间格间隔还小,没有更小的刻度,说明任务应该当即执行 if task.delay < tw.interval { threading.GoSafe(func() { tw.execute(timer.item.key, timer.item.value) }) return } // 若是 > interval,则经过 延迟时间delay 计算其出时间轮中的 new pos, circle pos, circle := tw.getPositionAndCircle(task.delay) if pos >= timer.pos { timer.item.circle = circle // 记录先后的移动offset。为了后面过程从新入队 timer.item.diff = pos - timer.pos } else if circle > 0 { // 转移到下一层,将 circle 转换为 diff 一部分 circle-- timer.item.circle = circle // 由于是一个数组,要加上 numSlots [也就是至关于要走到下一层] timer.item.diff = tw.numSlots + pos - timer.pos } else { // 若是 offset 提早了,此时 task 也还在第一层 // 标记删除老的 task,并从新入队,等待被执行 timer.item.removed = true newItem := &timingEntry{ baseEntry: task, value: timer.item.value, } tw.slots[pos].PushBack(newItem) tw.setTimerPosition(pos, newItem) } }
以上过程有如下几种状况:
delay < internal
:由于 < 单个时间精度,表示这个任务已通过期,须要立刻执行delay
:
new >= old
:<newPos, newCircle, diff>
newCircle > 0
:计算diff,并将 circle 转换为 下一层,故diff + numslots以前在初始化中,run()
中定时器的不断推动,推动的过程主要就是把 list中的 task 传给执行的 execute func
。咱们从定时器的执行开始看:
// 定时器 「每隔 internal 会执行一次」 func (tw *TimingWheel) onTick() { // 每次执行更新一下当前执行 tick 位置 tw.tickedPos = (tw.tickedPos + 1) % tw.numSlots // 获取此时 tick位置 中的存储task的双向链表 l := tw.slots[tw.tickedPos] tw.scanAndRunTasks(l) }
紧接着是如何去执行 execute
:
func (tw *TimingWheel) scanAndRunTasks(l *list.List) { // 存储目前须要执行的task{key, value} [execute所须要的参数,依次传递给execute执行] var tasks []timingTask for e := l.Front(); e != nil; { task := e.Value.(*timingEntry) // 标记删除,在 scan 中作真正的删除 「删除map的data」 if task.removed { next := e.Next() l.Remove(e) tw.timers.Del(task.key) e = next continue } else if task.circle > 0 { // 当前执行点已通过期,可是同时不在第一层,因此当前层即然已经完成了,就会降到下一层 // 可是并无修改 pos task.circle-- e = e.Next() continue } else if task.diff > 0 { // 由于以前已经标注了diff,须要再进入队列 next := e.Next() l.Remove(e) pos := (tw.tickedPos + task.diff) % tw.numSlots tw.slots[pos].PushBack(task) tw.setTimerPosition(pos, task) task.diff = 0 e = next continue } // 以上的状况都是不能执行的状况,可以执行的会被加入tasks中 tasks = append(tasks, timingTask{ key: task.key, value: task.value, }) next := e.Next() l.Remove(e) tw.timers.Del(task.key) e = next } // for range tasks,而后把每一个 task->execute 执行便可 tw.runTasks(tasks) }
具体的分支状况在注释中说明了,在看的时候能够和前面的 moveTask()
结合起来,其中 circle
降低,diff
的计算是关联两个函数的重点。
至于 diff
计算就涉及到 pos, circle
的计算:
// interval: 4min, d: 60min, numSlots: 16, tickedPos = 15 // step = 15, pos = 14, circle = 0 func (tw *TimingWheel) getPositionAndCircle(d time.Duration) (pos int, circle int) { steps := int(d / tw.interval) pos = (tw.tickedPos + steps) % tw.numSlots circle = (steps - 1) / tw.numSlots return }
上面的过程能够简化成下面:
steps = d / interval pos = step % numSlots - 1 circle = (step - 1) / numSlots
timingWheel
靠定时器推进,时间前进的同时会取出当前时间格中 list
「双向链表」的task,传递到 execute
中执行。由于是是靠 internal
固定时间刻度推动,可能就会出现:一个 60s 的task,internal = 1s
,这样就会空跑59次loop。
而在扩展时间上,采起 circle
分层,这样就能够不断复用原有的 numSlots
,由于定时器在不断 loop
,而执行能够把上层的 slot
降低到下层,在不断 loop
中就能够执行到上层的task。这样的设计能够在不创造额外的数据结构,突破长时间的限制。
同时在
go-zero
中还有不少实用的组件工具,用好工具对于提高服务性能和开发效率都有很大的帮助,但愿本篇文章能给你们带来一些收获。
https://github.com/tal-tech/go-zero
好将来技术