在平时写代码的时候，我们经常会遇到在将来某个时间点或者间隔一段时间重复执行函数。这个时候我们就可以考虑使用定时器。本片文章主要介绍一下golang当中的几个常用的定时器。time.Timer,time.Ticker,time.After以及time.AfterFunc和time.Ticker的基本使用
golang当中的定时器有这个一次性的定时器（Timer)和周期性的定时器(Ticker).在平时的编程当中经常会使用timer当中的ticker,AfterFunc定时器，而NewTicker是每隔多长时间触发，NewTimer是等待多长时间触发一次请注意是只触发一次。请注意一下两者的区别。
下面我们来首先来使用一下这两个定时器首先是这个Timer定时器
package main
import (
"fmt"
"time"
)
func main() {
myTimer := time.NewTimer(time.Second * 3) //初始化定时器
var i = 0
for {
select {
case <-myTimer.C:
i++
fmt.Printf("the counter is%d", i)
myTimer.Reset(time.Second * 3) //注意需要重新设置
}
}
myTimer.Stop() //不在使用需要将其停止
}
注意这个timer定时器超时之后需要重新进行设置，才能重新触发。如果上面的代码我们没有Reset，那么就会导致死锁。其实我们也可以看看这个Timer是怎么是实现的
func NewTimer(d Duration) *Timer {
c := make(chan Time, 1)
t := &Timer{
C: c, // 信道
r: runtimeTimer{
when: when(d), // 触发时间
f: sendTime, // 时间到了之后的调用函数
arg: c, // 调用sendTime时的入参
},
}
startTimer(&t.r) // 把定时器的r字段放入由定时器维护协程维护的堆中
return t
}
从上面的构造函数中可以大概看出定时器的工作流程，这里面最重要的是runtimeTimer。构造定时器的时候会把runtimeTimer放入由定时器维护协程维护的堆中，当时间到了之后，维护协程把r从堆中移除，并调用r的sendTime函数，sendTime的入参是定时器的信道C。可以推断，sendTime中执行的逻辑应该是向信道C中推送时间，通知上游系统时间到了，而事实正是如此：
func sendTime(c interface{}, seq uintptr) {
// Non-blocking send of time on c.
// Used in NewTimer, it cannot block anyway (buffer).
// Used in NewTicker, dropping sends on the floor is
// the desired behavior when the reader gets behind,
// because the sends are periodic.
select {
case c.(chan Time) <- Now(): //时间到了之后把当前时间放入信道中
default:
}
}
其实这个time.After就是对这个time.Timer的一个封装，所以如果我们上面使用这个time.After那么会频繁的创建time.Timer对象
下面我们在来看一下这个time.AterFunc（）定时器。
Golang当中的AfterFunc函数用于等待经过时间，此后在其自己的协程当中调用定义的函数f.函数在时间包下定义。下面我们一起看看如何使用这个
import (
"fmt"
"time"
)
func main() {
f := func() {
fmt.Println("the func is call after 3 second")
}
myTime := time.AfterFunc(time.Second*3, f)
defer myTime.Stop() //定时器不用了需要关闭
time.Sleep(time.Second * 4)
}
下面我们在看看这个time.NewTicker定时器的使用
package main
import (
"fmt"
"time"
)
func main() {
mytick := time.NewTicker(time.Second * 2)
defer mytick.Stop() //定时器不用了需要关闭
done := make(chan struct{})
go func() {
for {
time.Sleep(time.Second * 10)
done <- struct{}{}
}
}()
for {
select {
case <-done:
fmt.Println("done!!!!")
return
case t := <-mytick.C:
fmt.Printf("the curtime is %v\n", t)
}
}
}
下面我们来看一下这个陷阱，这个需要注意
package main
import (
"fmt"
"time"
)
func main() {
var count int
for {
select {
case <-time.Tick(time.Second * 1):
fmt.Println("case1")
count++
fmt.Println("count--->", count)
case <-time.Tick(time.Second * 2):
fmt.Println("case2")
count++
fmt.Println("count--->", count)
}
}
}
这个代码是有陷阱的，下面我们来看看这个运行结果是什么？
可见 case2 永远没有被执行到，问题就出在代码逻辑上，首先看time.Tick方法。我们可以看一下这个方法就知道
func Tick(d Duration) <-chan Time {
if d <= 0 {
return nil
}
return NewTicker(d).C
}
它每次都会创建一个新的定时器，随着 for 循环进行， select 始终监听两个新创建的定时器，老的定时器被抛弃掉了，也就不会去读取老定时器中的通道。
select 可以同时监听多个通道，谁先到达就先读取谁，如果同时有多个通道有消息到达，那么会随机读取一个通道，其他的通道由于没有被读取，所以数据不会丢失，需要循环调用 select 来读取剩下的通道。
总结：