从源码解析golang Timer定时器体系

// fntimer1 timer的使用用法
func fntimer1() {
	timer := time.newtimer(time.second * 5) //返回生成的timer
	fmt.printf("timer 的启动时间为:%v\n", time.now())

	expire := <-timer.c //注意这个channel是一个容量为1的channel！
	fmt.printf("timer 的触发时间为:%v\n", expire)
}

func fntimer2() {
	ch1 := make(chan int, 1)
	select {
	case e1 := <-ch1:
		//如果ch1通道成功读取数据，则执行该case处理语句
		fmt.printf("1th case is selected. e1=%v",e1)
	case <- time.after(2 * time.second): //time.after直接返回生成的timer的channel，所以一般用于超时控制
		fmt.println("timed out")
	}
}

func fntimer3() {
	_ = time.afterfunc(time.second*5, func() { //返回的也是timer，不过可以自己传入函数进行执行
		fmt.printf("定时器触发了,触发时间为%v\n", time.now())
	})

	fmt.printf("timer 的启动时间为:%v\n", time.now())
	time.sleep(10 * time.second) // 确保定时器触发
}

// fnticket2 ticker的正确的使用方法！！
func fnticket2() {
	ticker := time.newticker(1 * time.second)
	stopticker := make(chan struct{})
	defer ticker.stop()
	go func() {
		for {
			select {
			case now := <-ticker.c:
				// do something
				fmt.printf("ticker 的触发时间为:%v\n", now)
			case <-stopticker:
				fmt.println("ticker 结束")
				return
			}
		}
	}()

	time.sleep(4 * time.second)
	stopticker <- struct{}{}
}

// package time knows the layout of this structure.
// if this struct changes, adjust ../time/sleep.go:/runtimetimer.
type timer struct {
	// if this timer is on a heap, which p's heap it is on.
	// puintptr rather than *p to match uintptr in the versions
	// of this struct defined in other packages.
	pp puintptr //指针，指向持有当前timer的p

	// timer wakes up at when, and then at when+period, ... (period > 0 only)
	// each time calling f(arg, now) in the timer goroutine, so f must be
	// a well-behaved function and not block.
	//
	// when must be positive on an active timer.
	when   int64              //当前计时器被唤醒的时间；
	period int64              //两次被唤醒的间隔；
	f      func(any, uintptr) //唤醒时要执行的函数
	arg    any                // 计时器被唤醒时调用 f 传入的参数；
	seq    uintptr

	// what to set the when field to in timermodifiedxx status.
	nextwhen int64 //当定时器状态变为timermodifiedxx的时，when 字段下一次要设置的值

	// the status field holds one of the values below.
	status uint32 //计时器的状态，最重要的字段之一
}

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 //操作timers的时候加锁

	// actions to take at some time. this is used to implement the
	// standard library's time package.
	// must hold timerslock to access.
	timers []*timer //timers数组

	// number of timers in p's heap.
	// modified using atomic instructions.
	numtimers uint32 //总timers的数量

	// number of timerdeleted timers in p's heap.
	// modified using atomic instructions.
	deletedtimers uint32 //处于deleted状态的timers的数量

	// race context used while executing timer functions.
	timerracectx uintptr //竞态检测相关
}

@startuml

[*] --> timernostatus : 运行时创建timer

timernostatus -->timerwaiting : addtimer

timerwaiting -->timermodifying : deltimer、modtimer

timermodifying -->timerdeleted : deltimer

timermodifiedlater -->timerdeleted : deltimer

timermodifiedearlier -->timermodifying : deltimer


timerdeleted -->timerremoving : cleantimers、adjusttimers、runtimer

timerremoving -->timerremoved : cleantimers、adjusttimers、runtimer

timermodifiedearlier --> timermoving : cleantimers、adjusttimers

timermodifiedlater --> timermoving : cleantimers、adjusttimers

timermoving --> timerwaiting : cleantimers

timerwaiting --> timerrunning : runtimer

timerrunning --> timerwaiting : runtimer

timerrunning --> timernostatus : runtimer

state timermodifiedxx {
  state timermodifiedearlier {
  }
  state timermodifiedlater {
  }
}

timermodifying --> timermodifiedxx : modtimer
timermodifiedxx --> timermodifying : modtimer

timernostatus   --> timermodifying : modtimer
timermodifying --> timerwaiting : modtimer
timerremoved --> timermodifying : modtimer
timerdeleted    --> timermodifying : modtimer

timerwaiting : 定时器等待触发
timermodifying : 定时器状态修改的中间态
timerdeleted : 定时器被标记删除的状态

timerremoving: 定时器从标记删除到真正被删除的中间态
timerremoved: 定时器真正被删除

timermodifiedearlier: 定时器被修改到了更早的触发时间
timermodifiedlater : 定时器被修改到了更晚的触发时间

timermoving: 定时器在堆上的位置正在重新排序
timerrunning: timer正在运行
timermodifiedxx: 定时器在堆上的位置等待重新排序

@enduml

// addtimer:
//   timernostatus   -> timerwaiting
//   anything else   -> panic: invalid value
// deltimer:
//   timerwaiting         -> timermodifying -> timerdeleted
//   timermodifiedearlier -> timermodifying -> timerdeleted
//   timermodifiedlater   -> timermodifying -> timerdeleted
//   timernostatus        -> do nothing
//   timerdeleted         -> do nothing
//   timerremoving        -> do nothing
//   timerremoved         -> do nothing
//   timerrunning         -> wait until status changes
//   timermoving          -> wait until status changes
//   timermodifying       -> wait until status changes
// modtimer:
//   timerwaiting    -> timermodifying -> timermodifiedxx
//   timermodifiedxx -> timermodifying -> timermodifiedyy
//   timernostatus   -> timermodifying -> timerwaiting
//   timerremoved    -> timermodifying -> timerwaiting
//   timerdeleted    -> timermodifying -> timermodifiedxx
//   timerrunning    -> wait until status changes
//   timermoving     -> wait until status changes
//   timerremoving   -> wait until status changes
//   timermodifying  -> wait until status changes
// cleantimers (looks in p's timer heap):
//   timerdeleted    -> timerremoving -> timerremoved
//   timermodifiedxx -> timermoving -> timerwaiting
// adjusttimers (looks in p's timer heap):
//   timerdeleted    -> timerremoving -> timerremoved
//   timermodifiedxx -> timermoving -> timerwaiting
// runtimer (looks in p's timer heap):
//   timernostatus   -> panic: uninitialized timer
//   timerwaiting    -> timerwaiting or
//   timerwaiting    -> timerrunning -> timernostatus or
//   timerwaiting    -> timerrunning -> timerwaiting
//   timermodifying  -> wait until status changes
//   timermodifiedxx -> timermoving -> timerwaiting
//   timerdeleted    -> timerremoving -> timerremoved
//   timerrunning    -> panic: concurrent runtimer calls
//   timerremoved    -> panic: inconsistent timer heap
//   timerremoving   -> panic: inconsistent timer heap
//   timermoving     -> panic: inconsistent timer heap

func addtimer(t *timer) {
	 // xxx
	if t.status != timernostatus {
		throw("addtimer called with initialized timer")
	}
	t.status = timerwaiting

	when := t.when

	// disable preemption while using pp to avoid changing another p's heap.
	mp := acquirem()

	pp := getg().m.p.ptr()
	lock(&pp.timerslock)
	cleantimers(pp)       //尝试清除timers堆中堆头的元素，以加速定时器添加
	doaddtimer(pp, t)
	unlock(&pp.timerslock)

	wakenetpoller(when)

	releasem(mp)
}

// deltimer deletes the timer t. it may be on some other p, so we can't
// actually remove it from the timers heap. we can only mark it as deleted.
// it will be removed in due course by the p whose heap it is on.
// reports whether the timer was removed before it was run.
func deltimer(t *timer) bool {
	for {
		switch s := atomic.load(&t.status); s {
		case timerwaiting, timermodifiedlater:
			// prevent preemption while the timer is in timermodifying.
			// this could lead to a self-deadlock. see #38070.
			mp := acquirem()
			if atomic.cas(&t.status, s, timermodifying) {
				// 必须要先拿到tpp，因为当状态设置为timerdeleted之后，timer就有可能被清除（cleantimers函数），就拿不到tpp了
				tpp := t.pp.ptr()
				if !atomic.cas(&t.status, timermodifying, timerdeleted) {
					badtimer()
				}
				releasem(mp)
				atomic.xadd(&tpp.deletedtimers, 1)
				// timer was not yet run.
				return true
			} else {
				releasem(mp)
			}
		case timermodifiedearlier:
			// 这里和上面case的代码在源码中除了注释少一点其他一模一样，暂不清楚为什么
			mp := acquirem()
			if atomic.cas(&t.status, s, timermodifying) {
				tpp := t.pp.ptr() //先拿到tpp，原理同上
				if !atomic.cas(&t.status, timermodifying, timerdeleted) {
					badtimer()
				}
				releasem(mp)
				atomic.xadd(&tpp.deletedtimers, 1)
				// timer was not yet run.
				return true
			} else {
				releasem(mp)
			}
		case timerdeleted, timerremoving, timerremoved:
			// timer was already run.
			return false
		case timerrunning, timermoving:
			// the timer is being run or moved, by a different p.
			// wait for it to complete.
			osyield()
		case timernostatus:
			// removing timer that was never added or
			// has already been run. also see issue 21874.
			return false
		case timermodifying:
			// simultaneous calls to deltimer and modtimer.
			// wait for the other call to complete.
			osyield()
		default:
			badtimer()
		}
	}
}

//   timerwaiting    -> timermodifying -> timermodifiedxx
//   timermodifiedxx -> timermodifying -> timermodifiedyy
//   timernostatus   -> timermodifying -> timerwaiting
//   timerremoved    -> timermodifying -> timerwaiting
//   timerdeleted    -> timermodifying -> timermodifiedxx
//   timerrunning    -> wait until status changes
//   timermoving     -> wait until status changes
//   timerremoving   -> wait until status changes
//   timermodifying  -> wait until status changes

// resettimer resets the time when a timer should fire.
// if used for an inactive timer, the timer will become active.
// this should be called instead of addtimer if the timer value has been,
// or may have been, used previously.
// reports whether the timer was modified before it was run.
func resettimer(t *timer, when int64) bool {
	return modtimer(t, when, t.period, t.f, t.arg, t.seq)
}

// cleantimers cleans up the head of the timer queue. this speeds up
// programs that create and delete timers; leaving them in the heap
// slows down addtimer. reports whether no timer problems were found.
// the caller must have locked the timers for pp.
func cleantimers(pp *p) {
	gp := getg()
	for {
		if len(pp.timers) == 0 {
			return
		}

		t := pp.timers[0]

		switch s := atomic.load(&t.status); s {
		case timerdeleted: //被标记删除，现在正式移除
			if !atomic.cas(&t.status, s, timerremoving) {
				continue
			}
			dodeltimer0(pp)
			if !atomic.cas(&t.status, timerremoving, timerremoved) {
				badtimer()
			}
			atomic.xadd(&pp.deletedtimers, -1)
		case timermodifiedearlier, timermodifiedlater: //定时器被调整，移动其到正确的位置
			if !atomic.cas(&t.status, s, timermoving) {
				continue
			}
			// now we can change the when field.
			t.when = t.nextwhen
			// move t to the right position.
			dodeltimer0(pp)
			doaddtimer(pp, t)
			if !atomic.cas(&t.status, timermoving, timerwaiting) {
				badtimer()
			}
		default:
			// head of timers does not need adjustment.
			return
		}
	}
}

// adjusttimers (looks in p's timer heap):
//   timerdeleted    -> timerremoving -> timerremoved
//   timermodifiedxx -> timermoving -> timerwaiting

// runtimer (looks in p's timer heap):
//   timernostatus   -> panic: uninitialized timer
//   timerwaiting    -> timerwaiting or
//   timerwaiting    -> timerrunning -> timernostatus or
//   timerwaiting    -> timerrunning -> timerwaiting
//   timermodifying  -> wait until status changes
//   timermodifiedxx -> timermoving -> timerwaiting
//   timerdeleted    -> timerremoving -> timerremoved
//   timerrunning    -> panic: concurrent runtimer calls
//   timerremoved    -> panic: inconsistent timer heap
//   timerremoving   -> panic: inconsistent timer heap
//   timermoving     -> panic: inconsistent timer heap

if len(pp.timers) > 0 {
		adjusttimers(pp, now)
		for len(pp.timers) > 0 {
			// note that runtimer may temporarily unlock
			// pp.timerslock.
			if tw := runtimer(pp, now); tw != 0 {
				if tw > 0 {
					polluntil = tw
				}
				break
			}
			ran = true
		}
}

// checktimers runs any timers for the p that are ready.
// if now is not 0 it is the current time.
// it returns the passed time or the current time if now was passed as 0.
// and the time when the next timer should run or 0 if there is no next timer,
// and reports whether it ran any timers.
// if the time when the next timer should run is not 0,
// it is always larger than the returned time.
// we pass now in and out to avoid extra calls of nanotime.
//go:yeswritebarrierrec
func checktimers(pp *p, now int64) (rnow, polluntil int64, ran bool) {
	// if it's not yet time for the first timer, or the first adjusted
	// timer, then there is nothing to do.
	next := int64(atomic.load64(&pp.timer0when))
	nextadj := int64(atomic.load64(&pp.timermodifiedearliest))
	if next == 0 || (nextadj != 0 && nextadj < next) {
		next = nextadj
	}

	if next == 0 {
		// no timers to run or adjust.
		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.
		//	当前并没有到触发时间，这个检查的目的就是为了查看位于deletedtimers状态的 定时器 的比例，如果比例过大，就要清理
        // 	清理就是调用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)

	if len(pp.timers) > 0 {
		adjusttimers(pp, now)  //上面生成的now会传下来，因此不用担心函数执行导致的时间流逝
		for len(pp.timers) > 0 {
			// note that runtimer may temporarily unlock
			// pp.timerslock.
			if tw := runtimer(pp, now); tw != 0 { //上面生成的now会传下来，因此不用担心函数执行导致的时间流逝
				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.
	//如果运行当前goroutine的p是持有timers数组的p 且 处于deletedtimers状态的定时器 比例超过1/4，就清理掉这部分的定时器。
	if pp == getg().m.p.ptr() && int(atomic.load(&pp.deletedtimers)) > len(pp.timers)/4 {
		cleardeletedtimers(pp)
	}

	unlock(&pp.timerslock)

	return now, polluntil, ran
}

// this is the only function that walks through the entire timer heap,
// other than movetimers which only runs when the world is stopped.
func cleardeletedtimers(pp *p) {

// active timers live in heaps attached to p, in the timers field.
// inactive timers live there too temporarily, until they are removed.

// package time knows the layout of this structure.
// if this struct changes, adjust ../time/sleep.go:/runtimetimer.
// for goos=nacl, package syscall knows the layout of this structure.
// if this struct changes, adjust ../syscall/net_nacl.go:/runtimetimer.
type timer struct {
	i int // heap index

	// timer wakes up at when, and then at when+period, ... (period > 0 only)
	// each time calling f(arg, now) in the timer goroutine, so f must be
	// a well-behaved function and not block.
	when   int64                      //当前计时器被唤醒的时间
	period int64                      //两次被唤醒的间隔；
	f      func(interface{}, uintptr) //每当计时器被唤醒时都会调用的函数；
	arg    interface{}                //计时器被唤醒时调用 f 传入的参数；
	seq    uintptr
}

// interface to timers implemented in package runtime.
// must be in sync with ../runtime/time.go:/^type timer
type runtimetimer struct {
	i      int
	when   int64
	period int64
	f      func(interface{}, uintptr) // note: must not be closure
	arg    interface{}
	seq    uintptr
}

	// disable preemption while using pp to avoid changing another p's heap.
	mp := acquirem()

	pp := getg().m.p.ptr()
	lock(&pp.timerslock)
	cleantimers(pp)
	doaddtimer(pp, t)
	unlock(&pp.timerslock)

	wakenetpoller(when)

	releasem(mp)

// the timer is in some other p's heap, so we can't change
		// the when field. if we did, the other p's heap would
		// be out of order. so we put the new when value in the
		// nextwhen field, and let the other p set the when field
		// when it is prepared to resort the heap.

if !atomic.cas(&t.status, s, timermoving) {
	continue //continue用于等待重试
}

for {
		if t.status == s{ //双重校验，延迟加锁
			t.mu.lock() // 锁定
			if t.status == s {
				t.status = timermoving // 修改状态
				t.mu.unlock()           // 释放锁
				break                    // 修改成功，退出
			}
			t.mu.unlock() // 如果没有修改成功，解锁
		}
		// 继续等待重试
	}

func addtimer(t *timer) {
	// when must be positive. a negative value will cause runtimer to
	// overflow during its delta calculation and never expire other runtime
	// timers. zero will cause checktimers to fail to notice the timer.
	if t.when <= 0 {
		throw("timer when must be positive")
	}
	if t.period < 0 {
		throw("timer period must be non-negative")
	}
	if t.status != timernostatus {
		throw("addtimer called with initialized timer")
	}
xxx
}

// starttimer adds t to the timer heap.
//
//go:linkname starttimer time.starttimer
func starttimer(t *timer) {
	if raceenabled {
		racerelease(unsafe.pointer(t))
	}
	addtimer(t)
}

// updatetimermodifiedearliest updates the recorded nextwhen field of the
// earlier timermodifiedearier value.
// the timers for pp will not be locked.
func updatetimermodifiedearliest(pp *p, nextwhen int64) {
	for {
		old := atomic.load64(&pp.timermodifiedearliest)
		if old != 0 && int64(old) < nextwhen {
			return
		}
		if atomic.cas64(&pp.timermodifiedearliest, old, uint64(nextwhen)) {
			return
		}
	}
}

// doaddtimer adds t to the current p's heap.
// the caller must have locked the timers for pp.   //注释说明，这个函数必须锁定之后才能进入
func doaddtimer(pp *p, t *timer) {

xxx
}