go语言Timer计时器的用法示例详解

计时器用来定时执行任务，分享一段代码：

package main
import "time"
import "fmt"
func main() {
//新建计时器，两秒以后触发，go触发计时器的方法比较特别，就是在计时器的channel中发送值
timer1 := time.newtimer(time.second * 2)
//此处在等待channel中的信号，执行此段代码时会阻塞两秒
<-timer1.c
fmt.println("timer 1 expired")
//新建计时器，一秒后触发
timer2 := time.newtimer(time.second)
//新开启一个线程来处理触发后的事件
go func() {
//等触发时的信号
<-timer2.c
fmt.println("timer 2 expired")
}()
//由于上面的等待信号是在新线程中，所以代码会继续往下执行，停掉计时器
stop2 := timer2.stop()
if stop2 {
fmt.println("timer 2 stopped")
}
}

代码解读见注释。

最终输出结果为：

timer 1 expired

timer 2 stopped

因为timer 2的处理线程在等到信号前已经被停止掉了，所以会打印出timer 2 stopped而不是timer 2 expired

附录：下面看下go语言计时器的使用详解

go语言计时器

go语言的标准库里提供两种类型的计时器timer和ticker。timer经过指定的duration时间后被触发，往自己的时间channel发送当前时间，此后timer不再计时。ticker则是每隔duration时间都会把当前时间点发送给自己的时间channel，利用计时器的时间channel可以实现很多与计时相关的功能。

文章主要涉及如下内容：

• timer和ticker计时器的内部结构表示
• timer和ticker的使用方法和注意事项
• 如何正确reset定时器

计时器的内部表示

两种计时器都是基于go语言的运行时计时器runtime.timer实现的，rumtime.timer的结构体表示如下：

type timer struct {
 pp puintptr

 when int64
 period int64
 f func(interface{}, uintptr)
 arg interface{}
 seq uintptr
 nextwhen int64
 status uint32
}

rumtime.timer结构体中的字段含义是

• when— 当前计时器被唤醒的时间；
• period— 两次被唤醒的间隔；
• f— 每当计时器被唤醒时都会调用的函数；
• arg— 计时器被唤醒时调用 f传入的参数；
• nextwhen— 计时器处于 timermodifiedlater/timermodifiedeairlier状态时，用于设置 when字段；
• status— 计时器的状态；

这里的runtime.timer只是私有的计时器运行时表示，对外暴露的计时器 time.timer和time.ticker的结构体表示如下：

type timer struct {
 c <-chan time
 r runtimetimer
}

type ticker struct {
 c <-chan time 
 r runtimetimer
}

timer.c和ticker.c就是计时器中的时间channel，接下来我们看一下怎么使用这两种计时器，以及使用时要注意的地方。

timer计时器

time.timer计时器必须通过 time.newtimer、time.afterfunc或者 time.after函数创建。当计时器失效时，失效的时间就会被发送给计时器持有的 channel，订阅 channel的 goroutine会收到计时器失效的时间。

通过定时器timer用户可以定义自己的超时逻辑，尤其是在应对使用select处理多个channel的超时、单channel读写的超时等情形时尤为方便。timer常见的使用方法如下：

//使用time.afterfunc：

t := time.afterfunc(d, f)

//使用time.after：
select {
 case m := <-c:
 handle(m)
 case <-time.after(5 * time.minute):
 fmt.println("timed out")
}

// 使用time.newtimer:
t := time.newtimer(5 * time.minute)
select {
 case m := <-c:
 handle(m)
 case <-t.c:
 fmt.println("timed out")
}

time.afterfunc这种方式创建的timer，在到达超时时间后会在单独的goroutine里执行函数f。

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())()
}

从上面afterfunc的源码可以看到外面传入的f参数并非直接赋值给了运行时计时器的f，而是作为包装函数gofunc的参数传入的。gofunc会启动了一个新的goroutine来执行外部传入的函数f。这是因为所有计时器的事件函数都是由go运行时内唯一的goroutinetimerproc运行的。为了不阻塞timerproc的执行，必须启动一个新的goroutine执行到期的事件函数。

对于newtimer和after这两种创建方法，则是timer在超时后，执行一个标准库中内置的函数：sendtime。

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:
 }
}

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计时器

ticker可以周期性地触发时间事件，每次到达指定的时间间隔后都会触发事件。

time.ticker需要通过time.newticker或者time.tick创建。

// 使用time.tick:
go func() {
 for t := range time.tick(time.minute) {
 fmt.println("tick at", t)
 }
}()

// 使用time.ticker
var ticker *time.ticker = time.newticker(1 * time.second)

go func() {
 for t := range ticker.c {
 fmt.println("tick at", t)
 }
}()

time.sleep(time.second * 5)
ticker.stop() 
fmt.println("ticker stopped")

不过time.tick很少会被用到，除非你想在程序的整个生命周期里都使用time.ticker的时间channel。官文文档里对time.tick的描述是：

time.tick底层的ticker不能被垃圾收集器恢复；

所以使用time.tick时一定要小心，为避免意外尽量使用time.newticker返回的ticker替代。

newticker创建的计时器与newtimer创建的计时器持有的时间channel一样都是带一个缓存的channel，每次触发后执行的函数也是sendtime，这样即保证了无论有误接收方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
}

reset计时器时要注意的问题

关于reset的使用建议，文档里的描述是：

重置计时器时必须注意不要与当前计时器到期发送时间到t.c的操作产生竞争。如果程序已经从t.c接收到值，则计时器是已知的已过期，并且t.reset可以直接使用。如果程序尚未从t.c接收值，计时器必须先被停止，并且-如果使用t.stop时报告计时器已过期，那么请排空其通道中值。

例如：

if !t.stop() {
 <-t.c
}
t.reset(d)

下面的例子里producer goroutine里每一秒向通道中发送一个false值，循环结束后等待一秒再往通道里发送一个true值。在consumer goroutine里通过循环试图从通道中读取值，用计时器设置了最长等待时间为5秒，如果计时器超时了，输出当前时间并进行下次循环尝试，如果从通道中读取出的不是期待的值（预期值是true)，则尝试重新从通道中读取并重置计时器。

func main() {
 c := make(chan bool)

 go func() {
 for i := 0; i < 5; i++ {
  time.sleep(time.second * 1)
  c <- false
 }

 time.sleep(time.second * 1)
 c <- true
 }()

 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 is active , not fired, stop always returns true, no problems occurs.
  if !timer.stop() {
  <-timer.c
  }
  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
  }
 }
 }()

 //to avoid that all goroutine blocks.
 var s string
 fmt.scanln(&s)
}

程序的输出如下：

2020-05-13 12:49:48.90292 +0800 cst m=+1.004554120 :recv false. continue
2020-05-13 12:49:49.906087 +0800 cst m=+2.007748042 :recv false. continue
2020-05-13 12:49:50.910208 +0800 cst m=+3.011892138 :recv false. continue
2020-05-13 12:49:51.914291 +0800 cst m=+4.015997373 :recv false. continue
2020-05-13 12:49:52.916762 +0800 cst m=+5.018489240 :recv false. continue
2020-05-13 12:49:53.920384 +0800 cst m=+6.022129708 :recv true. return

目前来看没什么问题，使用reset重置计时器也起作用了，接下来我们对producer goroutin做一些更改，我们把producer goroutine里每秒发送值的逻辑改成每6秒发送值，而consumer gouroutine里和计时器还是5秒就到期。

// producer
 go func() {
 for i := 0; i < 5; i++ {
  time.sleep(time.second * 6)
  c <- false
 }

 time.sleep(time.second * 6)
 c <- true
 }()

再次运行会发现程序发生了deadlock在第一次报告计时器过期后直接阻塞住了：

2020-05-13 13:09:11.166976 +0800 cst m=+5.005266022 :timer expired

那程序是在哪阻塞住的呢？对就是在抽干timer.c通道时阻塞住了（英文叫做drain channel比喻成流干管道里的水，在程序里就是让timer.c管道中不再存在未接收的值)。

producer goroutine的发送行为发生了变化，comsumer goroutine在收到第一个数据前有了一次计时器过期的事件，for循环进行一下次循环。这时timer.stop函数返回的不再是true，而是false，因为计时器已经过期了，上面提到的维护着所有活跃计时器的最小堆中已经不包含该计时器了。而此时timer.c中并没有数据，接下来用于drain channel的代码会将consumer goroutine阻塞住。

这种情况，我们应该直接reset计时器，而不用显式drain channel。如何将这两种情形合二为一呢？我们可以利用一个select来包裹drain channel的操作，这样无论channel中是否有数据，drain都不会阻塞住。

//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 {
  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
  }
 }
 }()

运行修改后的程序，发现程序不会被阻塞住，能正常进行通道读取，读取到true值后会自行退出。输出结果如下：

2020-05-13 13:25:08.412679 +0800 cst m=+5.005475546 :timer expired
2020-05-13 13:25:09.409249 +0800 cst m=+6.002037341 :recv false. continue
2020-05-13 13:25:14.412282 +0800 cst m=+11.005029547 :timer expired
2020-05-13 13:25:15.414482 +0800 cst m=+12.007221569 :recv false. continue
2020-05-13 13:25:20.416826 +0800 cst m=+17.009524859 :timer expired
2020-05-13 13:25:21.418555 +0800 cst m=+18.011245687 :recv false. continue
2020-05-13 13:25:26.42388 +0800 cst m=+23.016530193 :timer expired
2020-05-13 13:25:27.42294 +0800 cst m=+24.015582511 :recv false. continue
2020-05-13 13:25:32.425666 +0800 cst m=+29.018267054 :timer expired
2020-05-13 13:25:33.428189 +0800 cst m=+30.020782483 :recv false. continue
2020-05-13 13:25:38.432428 +0800 cst m=+35.024980796 :timer expired
2020-05-13 13:25:39.428343 +0800 cst m=+36.020887629 :recv true. return

总结

以上比较详细地介绍了go语言的计时器以及它们的使用方法和注意事项，总结一下有如下关键点：

• timer和ticker都是在运行时计时器runtime.timer的基础上实现的。
• 运行时里的所有计时器都由运行时内唯一的timerproc触发。
• time.tick创建的ticker在运行时不会被gc回收，能不用就不用。
• timer和ticker的时间channel都是带有一个缓冲的通道。
• time.after，time.newtimer，time.newticker创建的计时器触发时都会执行sendtime。
• sendtime和计时器带缓冲的时间通道保证了计时器不会阻塞程序。
• reset计时器时要注意drain channel和计时器过期存在竞争条件。

到此这篇关于详解go 语言计时器的使用的文章就介绍到这了,更多相关go 语言计时器内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！