Go 语言的标准库里提供两种类型的计时器Timer和Ticker。Timer 经过指定的 duration 时间后被触发，往自己的 time channel 发送当前时间，此后 Timer 不再计时。Ticker 则是每隔 duration 时间都会把当前时间点发送给自己的 time channel，利用计时器的 time channel 可以实现很多与计时相关的功能。
值得一提的是，两种计时器都是基于 Go 语言的运行时计时器 runtime.timer 实现的，runtime.timer 的结构体表示如下：
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 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(interface{}, uintptr) // 每当计时器被唤醒时都会调用的函数；
arg interface{} // 计时器被唤醒时调用 f 传入的参数；
seq uintptr
// What to set the when field to in timerModifiedXX status.
nextwhen int64 // 计时器处于 timerModifiedLater/timerModifiedEairlier 状态时，用于设置 when 字段；
// The status field holds one of the values below.
status uint32 // 计时器的状态；
}
我们来看两者结构和方法的对比：
Timer
type Timer struct {
C <-chan time.Time
// contains filtered or unexported fields
}
func AfterFunc(d Duration, f func()) *Timer {
t := &Timer{
r: runtimeTimer{
when: when(d),
f: goFunc,
arg: f,
},
}
startTimer(&t.r)
return t
}
func goFunc(arg interface{}, seq uintptr) {
go arg.(func())()
}
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 sendTime(c interface{}, seq uintptr) {
select {
case c.(chan Time) <- Now():
default:
}
}
func (t *Timer) Pause() bool
func (t *Timer) Start() bool
func (t *Timer) Stop() bool
在使用时，Timer 计时器必须通过 time.NewTimer、time.AfterFunc 或者 time.After 函数创建。 当计时器失效时，失效的时间就会被发送给计时器持有的 channel，订阅 channel 的 goroutine 会收到计时器失效的时间。
从上面AfterFunc的源码可以看到外面传入的f参数并非直接赋值给了运行时计时器的f，而是作为包装函数goFunc的参数传入的。goFunc会启动了一个新的goroutine来执行外部传入的函数f。这是因为所有计时器的事件函数都是由Go运行时内唯一的 goroutine timerproc运行的。为了不阻塞timerproc的执行，必须启动一个新的goroutine执行到期的事件函数。
对于NewTimer和After这两种创建方法，则是Timer在超时后，执行一个标准库中内置的函数：sendTime。sendTime将当前时间发送到Timer的时间channel中。那么这个动作不会阻塞timerproc的执行么？答案是不会，原因是NewTimer创建的是一个带缓冲的channel所以无论Timer.C这个channel有没有接收方sendTime都可以非阻塞的将当前时间发送给Timer.C，而且sendTime中还加了双保险：通过select判断Timer.C的Buffer是否已满，一旦满了，会直接退出，依然不会阻塞。
Timer的Stop方法可以阻止计时器触发，调用Stop方法成功停止了计时器的触发将会返回true，如果计时器已经过期了或者已经被Stop停止过了，再次调用Stop方法将会返回false。
Go运行时将所有计时器维护在一个最小堆Min Heap中，Stop一个计时器就是从堆中删除该计时器。
Ticker
type Ticker struct {
C chan time.Time // The channel on which ticks are delivered.
// contains filtered or unexported fields
}
func New(d time.Duration) *Ticker
func NewTicker(d Duration) *Ticker {
if d <= 0 {
panic(errors.New("non-positive interval for NewTicker"))
}
// Give the channel a 1-element time buffer.
// If the client falls behind while reading, we drop ticks
// on the floor until the client catches up.
c := make(chan Time, 1)
t := &Ticker{
C: c,
r: runtimeTimer{
when: when(d),
period: int64(d),
f: sendTime,
arg: c,
},
}
startTimer(&t.r)
return t
}
func sendTime(c interface{}, seq uintptr) {
select {
case c.(chan Time) <- Now():
default:
}
}
func (t *Ticker) Start()
func (t *Ticker) Stop()
func (t *Ticker) Stopped() bool
Ticker可以周期性地触发时间事件，每次到达指定的时间间隔后都会触发事件。
time.Ticker需要通过time.NewTicker或者time.Tick创建。
不过time.Tick很少会被用到，除非你想在程序的整个生命周期里都使用time.Ticker的时间channel。官文文档里对time.Tick的描述是：
time.Tick底层的Ticker不能被垃圾收集器恢复；
所以使用time.Tick时一定要小心，为避免意外尽量使用time.NewTicker返回的Ticker替代。
NewTicker创建的计时器与NewTimer创建的计时器持有的时间channel一样都是带一个缓存的channel，每次触发后执行的函数也是sendTime，这样就保证了无论有没有接收Ticker触发时间事件，都不会阻塞。
Reset计时器时要注意的问题
关于Reset的使用建议，文档里的描述是：
重置计时器时必须注意不要与当前计时器到期发送时间到t.C的操作产生竞争。如果程序已经从t.C接收到值，则计时器是已知的已过期，并且t.Reset可以直接使用。如果程序尚未从t.C接收值，计时器必须先被停止，并且如果使用t.Stop时报告计时器已过期，那么请排空其通道中值。
什么意思呢？简单来说就是如果计时器已经过期，抽干timer.C通道时，就会发生阻塞（英文叫做drain channel 比喻成流干管道里的水，在程序里就是让timer.C管道中不再存在未接收的值)。
那么如何解决呢？
//consumer
go func() {
// try to read from channel, block at most 5s.
// if timeout, print time event and go on loop.
// if read a message which is not the type we want(we want true, not false),
// retry to read.
timer := time.NewTimer(time.Second * 5)
for {
// timer may be not active, and fired
if !timer.Stop() {
select { // 这里使用了 select，而不是直接使用 <-timer.C
case <-timer.C: //try to drain from the channel
default:
}
}
timer.Reset(time.Second * 5)
select {
case b := <-c:
if b == false {
fmt.Println(time.Now(), ":recv false. continue")
continue
}
//we want true, not false
fmt.Println(time.Now(), ":recv true. return")
return
case <-timer.C:
fmt.Println(time.Now(), ":timer expired")
continue
}
}
}()
在 timer 停止时，直接Reset计时器，而不用显式drain channel。具体实现为利用一个select来包裹drain channel，这样无论channel中是否有数据，drain都不会阻塞住。
结论
-
Timer和Ticker都是在运行时计时器runtime.timer的基础上实现的。 - 运行时里的所有计时器的事件函数都由运行时内唯一的
goroutinetimerproc触发。 -
time.Tick创建的Ticker在运行时不会被gc回收，能不用就不用。 -
Timer和Ticker的时间channel都是带有一个缓冲的通道。 -
time.After，time.NewTimer，time.NewTicker创建的计时器触发时都会执行sendTime。 -
sendTime和计时器带缓存的时间通道保证了计时器不会阻塞程序。 -
Reset计时器时要注意drain channel和计时器过期存在竞争条件。
参考
详解Go语言的计时器
runtime.time.go
timer
ticker