今天带来Golang 定时器(Timer 和 Ticker),这篇文章就够了教程详解
定时器是什么
Golang 原生 time 包下可以用来执行一些定时任务或者是周期性的任务的一个工具
本文基于 Go 1.14，如果以下文章有哪里不对或者问题的地方，欢迎讨论学习
定时器的日常使用
Timer 相关
func NewTimer(d Duration) *Timer func (t *Timer) Reset(d Duration) bool func (t *Timer) Stop() bool func After(d Duration)注意事项：
错误使用：time.After 这里会不断生成 timer，虽然最终会回收，但是会造成无意义的cpu资源消耗
func main() { for { select { case正确使用：
func main() { timer := time.NewTimer(3 * time.Second) for { timer.Reset(3 * time.Second) // 这里复用了 timer select { caseTicker 相关
func NewTicker(d Duration) *Ticker func Tick(d Duration)错误使用：
func main() { for { select { case定时器源码分析
我先给出涉及到过程的相关结构体（！！！要注意 Timer 和 timer 的不同）
type Timer struct { C我们以 Ticker 为切入点
func NewTicker(d Duration) *Ticker { if d从 NewTicker 中我们可以看到，开始执行是在 startTimer()，我们进去看下
addtimer
// startTimer adds t to the timer heap. // 这里已经说明了 timers 是一种堆的数据结构，由于是定时器， // 最近的最先执行，所以猜测以 when 来判断的小顶堆 func startTimer(t *timer) { addtimer(t) } func addtimer(t *timer) { if t.when 0 { pp.timers[0] = pp.timers[last] } pp.timers[last] = nil pp.timers = pp.timers[:last] if last > 0 { siftdownTimer(pp.timers, 0)//向下调整的核心部分 } // --------------------- updateTimer0When(pp) //更新当前 p 的最先执行 timer 的执行时间 atomic.Xadd(&pp.numTimers, -1) } func updateTimer0When(pp *p) { if len(pp.timers) == 0 { atomic.Store64(&pp.timer0When, 0) } else { atomic.Store64(&pp.timer0When, uint64(pp.timers[0].when)) } } // timer 增加的源码部分 func doaddtimer(pp *p, t *timer) { ... if t.pp != 0 { throw("doaddtimer: P already set in timer") } t.pp.set(pp) // --- 将 timer 放置到堆的最后一位，然后向上调整 --- i := len(pp.timers) pp.timers = append(pp.timers, t) siftupTimer(pp.timers, i)// 向上调整的核心部分 // --------------------------- if t == pp.timers[0] { atomic.Store64(&pp.timer0When, uint64(t.when)) } atomic.Xadd(&pp.numTimers, 1) }当我们已知 timers 是小顶堆的数据结构（满足“当前位置的值小于等于父位置的值“即可，实现方式使用数组，由下面代码可以知道是四叉小顶堆，结构如下图）的情况后，接下来看堆向上或者向下调整的细节部分
// timers 堆的向上调整 func siftupTimer(t []*timer, i int) { ... when := t[i].when tmp := t[i] for i > 0 { p := (i - 1) / 4 // 由这里可以看出，堆的节点长度是4 if when >= t[p].when { break } // --- 向上进行调整，即父节点下移，当前节点上移 --- t[i] = t[p] i = p //向上进行调整 } if tmp != t[i] { t[i] = tmp } } //timers 堆的向下调整 func siftdownTimer(t []*timer, i int) { n := len(t) if i >= n { badTimer() } when := t[i].when tmp := t[i] for { // --- 以下部分就是找到当前4个节点中最小的那个值和在数组的位置 ----- c := i*4 + 1 // 这里是子节点最左边的节点 c3 := c + 2 // 这里是子节点第三个节点 if c >= n { break } w := t[c].when if c+1 = when { break } // --- 向下进行调整，即子节点上移，当前节点下移 --- t[i] = t[c] i = c // --------------- } if tmp != t[i] { t[i] = tmp } }既然已经知道timer放到四叉小顶堆，那 timer 是怎么执行的呢？接下来就是定时器的核心部分入口 runtimer()
runtimer
// 这里执行的前提是当前 P 的 timesLock 已经锁了，所以不用担心并发问题 func runtimer(pp *p, now int64) int64 { for { t := pp.timers[0] //找到 timers 堆的堆顶，为最先执行的 timer if t.pp.ptr() != pp { throw("runtimer: bad p") } switch s := atomic.Load(&t.status); s { case timerWaiting: if t.when > now { //如果还没到时间，则返回调用的时间 return t.when } if !atomic.Cas(&t.status, s, timerRunning) { continue } runOneTimer(pp, t, now)// 这里是执行timer的核心 return 0 case timerDeleted: if !atomic.Cas(&t.status, s, timerRemoving) { continue } dodeltimer0(pp) //删除 timers 堆顶的 timer if !atomic.Cas(&t.status, timerRemoving, timerRemoved) { badTimer() } atomic.Xadd(&pp.deletedTimers, -1) if len(pp.timers) == 0 { return -1 } case timerModifiedEarlier, timerModifiedLater: if !atomic.Cas(&t.status, s, timerMoving) { continue } //删除堆顶的位置，调整 timer 到最新的时间，以及进行重新调整 t.when = t.nextwhen dodeltimer0(pp) doaddtimer(pp, t) if s == timerModifiedEarlier { atomic.Xadd(&pp.adjustTimers, -1) } if !atomic.Cas(&t.status, timerMoving, timerWaiting) { badTimer() } case timerModifying: osyield() case timerNoStatus, timerRemoved: badTimer() case timerRunning, timerRemoving, timerMoving: badTimer() default: badTimer() } } }因此我们知道了执行的核心流程是 runOneTimer()
runOneTimer
// 由于是 runtimer 进行调用，因此也线程安全 func runOneTimer(pp *p, t *timer, now int64) { ... f := t.f arg := t.arg seq := t.seq if t.period > 0 { //如果有周期，则算出下次 timer 执行的时间，并加入到对应的位置（这里就是 Ticker 和 Timer 的区别） delta := t.when - now t.when += t.period * (1 + -delta/t.period) siftdownTimer(pp.timers, 0)// 将四叉小顶堆向下调整 if !atomic.Cas(&t.status, timerRunning, timerWaiting) { badTimer() } updateTimer0When(pp)//更新当前 P 的最先的 timer 的执行时间 } else { // 从堆顶位置上删除 timer，并调整 dodeltimer0(pp) if !atomic.Cas(&t.status, timerRunning, timerNoStatus) { badTimer() } } ... unlock(&pp.timersLock) f(arg, seq) // 执行对应的 f，这里就是我们 Timer.C 来的地方 lock(&pp.timersLock) ... }从 runtimer 的调用，我们知道执行的入口是 checkTimers()，我们详细看下
checkTimers
我们可以看下图，由下图可知，是通过 Go 里面的调度中去寻找可执行的 timer
我们看下 checkTimers 做了什么
func checkTimers(pp *p, now int64) (rnow, pollUntil int64, ran bool) { if atomic.Load(&pp.adjustTimers) == 0 {// 如果没有需要可调整的，则直接返回最先执行 timer 的时间 next := int64(atomic.Load64(&pp.timer0When)) if next == 0 { return now, 0, false } if now == 0 { now = nanotime() } if now 0 { if rnow == 0 { rnow = nanotime() } for len(pp.timers) > 0 { if tw := runtimer(pp, rnow); tw != 0 { // 通过 runtimer（可以看上面的源码解析） 开始调用 if tw > 0 { pollUntil = tw } break } ran = true } } // 如果可删除的 Timers 大于 Timer总数量的1/4，则进行删除（因为上面执行了 runtimer) if pp == getg().m.p.ptr() && int(atomic.Load(&pp.deletedTimers)) > len(pp.timers)/4 { clearDeletedTimers(pp) } unlock(&pp.timersLock) return rnow, pollUntil, ran }adjusttimers
func adjusttimers(pp *p) { if len(pp.timers) == 0 { return } if atomic.Load(&pp.adjustTimers) == 0 { // 如果需要调整的 Timer 为 0，则直接返回 ... return } var moved []*timer loop: for i := 0; i 0 { addAdjustedTimers(pp, moved) // 这里就是将需要调整的 timer 重新添加进来 } ... }addAdjustedTimers
func addAdjustedTimers(pp *p, moved []*timer) { for _, t := range moved { doaddtimer(pp, t)// 上文有源码解析 if !atomic.Cas(&t.status, timerMoving, timerWaiting) { badTimer() } } }clearDeletedTimers
func clearDeletedTimers(pp *p) { cdel := int32(0) cearlier := int32(0) to := 0 changedHeap := false timers := pp.timers nextTimer: for _, t := range timers { for { switch s := atomic.Load(&t.status); s { case timerWaiting: if changedHeap { timers[to] = t siftupTimer(timers, to) } to++ continue nextTimer case timerModifiedEarlier, timerModifiedLater: // 将 timer 状态调整成 timeWaiting，将其放至其正确的执行时间位置 if atomic.Cas(&t.status, s, timerMoving) { t.when = t.nextwhen timers[to] = t siftupTimer(timers, to) to++ changedHeap = true if !atomic.Cas(&t.status, timerMoving, timerWaiting) { badTimer() } if s == timerModifiedEarlier { cearlier++ } continue nextTimer } case timerDeleted: // 将 timerDeleted 转变成 timerRemoved，然后从 timers 堆中删掉（在当前函数后面可以看出） if atomic.Cas(&t.status, s, timerRemoving) { t.pp = 0 cdel++ if !atomic.Cas(&t.status, timerRemoving, timerRemoved) { badTimer() } changedHeap = true continue nextTimer } case timerModifying: osyield() case timerNoStatus, timerRemoved: badTimer() case timerRunning, timerRemoving, timerMoving: badTimer() default: badTimer() } } } // 在这里对于剩余的空间 设置为 nil 操作（垃圾回收方便） for i := to; i大致执行的情况我们看好了，那我们接下来看 Stop() 的源码部分
deltimer
func (t *Ticker) Stop() { stopTimer(&t.r) } func stopTimer(t *timer) bool { return deltimer(t) } func deltimer(t *timer) bool { for { switch s := atomic.Load(&t.status); s { case timerWaiting, timerModifiedLater: //将 timer 的 status变更为 timerDeleted ，并deletedTimers 加 1 mp := acquirem() if atomic.Cas(&t.status, s, timerModifying) { tpp := t.pp.ptr() if !atomic.Cas(&t.status, timerModifying, timerDeleted) { // badTimer() } releasem(mp) atomic.Xadd(&tpp.deletedTimers, 1) return true } else { releasem(mp) } case timerModifiedEarlier: //将 timer 的 status 变更为 timerDeleted，然后 adjustTimers 减 1，deletedTimers 加 1 mp := acquirem() if atomic.Cas(&t.status, s, timerModifying) { tpp := t.pp.ptr() atomic.Xadd(&tpp.adjustTimers, -1) if !atomic.Cas(&t.status, timerModifying, timerDeleted) { badTimer() } releasem(mp) atomic.Xadd(&tpp.deletedTimers, 1) return true } else { releasem(mp) } case timerDeleted, timerRemoving, timerRemoved: return false case timerRunning, timerMoving: osyield() case timerNoStatus: return false case timerModifying: osyield() default: badTimer() } } }后续调度中， Timer 的状态可以从 timerDeleted 设置成 timerRemoved 并从 timers 堆中去除（注意，这里用了“可以”，可以看上面的状态图了解）
在复用 Timer 的时候，我们经常使用 Reset()，我们来看下源码部分是怎么样的
modtimer
func (t *Timer) Reset(d Duration) bool { if t.r.f == nil { panic("time: Reset called on uninitialized Timer") } w := when(d) active := stopTimer(&t.r) // 这里我们上面源码解释过了，即将当前的 timer 的 status 设置成 timerDeleted resetTimer(&t.r, w) return active } func resettimer(t *timer, when int64) { modtimer(t, when, t.period, t.f, t.arg, t.seq) } func modtimer(t *timer, when, period int64, f func(interface{}, uintptr), arg interface{}, seq uintptr) { if when到此这篇关于Golang 定时器(Timer 和 Ticker),这篇文章就够了的文章就介绍到这了,更多相关Golang 定时器内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
以上就是关于Golang 定时器(Timer 和 Ticker),这篇文章就够了全部内容,感谢大家支持。查看更多关于Golang 定时器(Timer 和 Ticker),这篇文章就够了的详细内容...
声明：本文来自网络，不代表【好得很程序员自学网】立场，转载请注明出处：http://haodehen.cn/did31949