前言
前面分析了time包的Time 和 Location，今天分析下定时器Timer的相关实现和采坑实践，本次源码分析基于go1.15，因为Timer牵涉到golang runtime相关逻辑，不做深入，以后分析golang runtime 专门再看。
Timer 源码解析
Timer 向开发者提供了类：
- Timer: 执行一次的定时器,包含NewTimer、Stop、Reset三个方法
- Ticker: 和Timer极为相似，区别是Ticker是重复多次执行，直到执行Stop方法
先看下Timer源码
type Timer struct {
C <-chan Time
r runtimeTimer
}
type runtimeTimer struct {
pp uintptr // timer 所属的P的id
when int64 // 执行时间
period int64 // 对于Ticker 重复执行任务，period 是重复执行的间隔时间
f func(interface{}, uintptr) // NOTE: must not be closure
arg interface{}
seq uintptr
nextwhen int64 // 下次执行时间
status uint32 // 状态
}
func NewTimer(d Duration) *Timer {
c := make(chan Time, 1)
t := &Timer{
C: c,
r: runtimeTimer{
when: when(d),
f: sendTime,
arg: c,
},
}
startTimer(&t.r)
return t
}
func (t *Timer) Stop() bool {
if t.r.f == nil {
panic("time: Stop called on uninitialized Timer")
}
return stopTimer(&t.r)
}
func (t *Timer) Reset(d Duration) bool {
if t.r.f == nil {
panic("time: Reset called on uninitialized Timer")
}
w := when(d)
return resetTimer(&t.r, w)
}
Timer主要包含三个函数
- NewTimer: 创建并启动Timer
- Stop: 停止Timer
- Reset: 重置计时器
细节先不追究，看下startTimer
// src/runtime/time.go
func startTimer(t *timer) {
if raceenabled {
racerelease(unsafe.Pointer(t))
}
addtimer(t)
}
func addtimer(t *timer) {
// when must never be negative; otherwise runtimer will overflow
// during its delta calculation and never expire other runtime timers.
if t.when < 0 {
t.when = maxWhen
}
if t.status != timerNoStatus {
throw("addtimer called with initialized timer")
}
t.status = timerWaiting
when := t.when
pp := getg().m.p.ptr()
lock(&pp.timersLock)
cleantimers(pp)
doaddtimer(pp, t)
unlock(&pp.timersLock)
wakeNetPoller(when)
}
func doaddtimer(pp *p, t *timer) {
// Timers rely on the network poller, so make sure the poller
// has started.
if netpollInited == 0 {
netpollGenericInit()
}
if t.pp != 0 {
throw("doaddtimer: P already set in timer")
}
t.pp.set(pp)
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)
}
func siftupTimer(t []*timer, i int) {
if i >= len(t) {
badTimer()
}
when := t[i].when
tmp := t[i]
for i > 0 {
p := (i - 1) / 4 // parent
if when >= t[p].when {
break
}
t[i] = t[p]
i = p
}
if tmp != t[i] {
t[i] = tmp
}
}
startTimer函数的调用链:startTimer->addtimer->doaddtimer->siftupTimer. 从代码看出，go 1.15
- golang timer 采用四叉最小堆维护timer列表
- timer 最小堆和p绑定，需要加锁
那这个最小堆如何存储的呢，谁负责定时执行timer任务呢？答案是: P(golang 调度 GMP 模型中的P)
// src/runtime/runtime2.go
type p struct {
...
// Lock for timers. We normally access the timers while running
// on this P, but the scheduler can also do it from a different P.
timersLock mutex
// Actions to take at some time. This is used to implement the
// standard library's time package.
// Must hold timersLock to access.
timers []*timer
...
}
每个p维护一个Timer 的堆，在P进行协程调度的时候(调用schedule函数)，会调用checkTimers检查本P的定时器，并执行到期的定时任务
// src/runtime/proc.go
func schedule() {
_g_ := getg()
...
checkTimers(pp, 0)
}
看下checkTimers的源码吧
func checkTimers(pp *p, now int64) (rnow, pollUntil int64, ran bool) {
// If there are no timers to adjust, and the first timer on
// the heap is not yet ready to run, then there is nothing to do.
if atomic.Load(&pp.adjustTimers) == 0 {
next := int64(atomic.Load64(&pp.timer0When))
if next == 0 {
return now, 0, false
}
if now == 0 {
now = nanotime()
}
if now < next {
// Next timer is not ready to run.
// But keep going if we would clear deleted timers.
// This corresponds to the condition below where
// we decide whether to call clearDeletedTimers.
if pp != getg().m.p.ptr() || int(atomic.Load(&pp.deletedTimers)) <= int(atomic.Load(&pp.numTimers)/4) {
return now, next, false
}
}
}
lock(&pp.timersLock)
// 调整timer 堆，有些timer 会提前，延后或者删除等
adjusttimers(pp)
rnow = now
if len(pp.timers) > 0 {
if rnow == 0 {
rnow = nanotime()
}
for len(pp.timers) > 0 {
// Note that runtimer may temporarily unlock
// pp.timersLock.
// runtimer 将 timer 对应的任务协程放到p的执行队列
if tw := runtimer(pp, rnow); tw != 0 {
if tw > 0 {
pollUntil = tw
}
break
}
ran = true
}
}
// If this is the local P, and there are a lot of deleted timers,
// clear them out. We only do this for the local P to reduce
// lock contention on timersLock.
if pp == getg().m.p.ptr() && int(atomic.Load(&pp.deletedTimers)) > len(pp.timers)/4 {
clearDeletedTimers(pp)
}
unlock(&pp.timersLock)
return rnow, pollUntil, ran
}
从代码一步步往下追，相对来说不是很难，不赘述。
Timer采坑
内存泄漏
package main
import (
"time"
"log"
)
func main() {
ticker := time.NewTicker(1 * time.Second)
go func(){
for _ = range ticker.C {
log.Println("tick")
}
log.Println("ticker channel stopped")
}()
time.Sleep(5 * time.Second)
log.Println("stopping ticker")
ticker.Stop()
time.Sleep(5 * time.Second)
}
main函数里面启动的携程并不会自动结束，也就是无法执行到log.Println("stopped")这一行，会阻塞在ticker.C。如果main是一个长时间执行的服务(如web服务器)，那么这个泄漏将是致命的.
总结
golang 1.15 对于timer的实现总结几点
- 每个P维护一个四叉堆，P进行协程调度时，会判断check timer 是否到期，并执行
- 如果发现当前P无timer，会从其他P偷取，这个和GMP偷取其他P的G是一样的(这块代码没有详细分析)
- timer 实现的细节方面因为和golang runtime 关系比较紧密，所以没有深入，打算分析runtime再细分析
- 堆的插入、删除这个大家可以复习下
自此，两篇文章，time包的代码基本分析完了，准备下一个atomic 还是 unsafe呢，暂时先不对golang runtime动手(准备不足)，哈哈哈哈
golang社区
知识星球，一起golang: t.zsxq.com/nUR723R 博客: blog.17ledong.com/
