Golang中定时器的陷阱详解

前言

在业务中,我们经常需要基于定时任务来触发来实现各种功能。比如ttl会话管理、锁、定时任务(闹钟)或更复杂的状态切换等等。百纳网主要给大家介绍了关于golang定时器陷阱的相关内容，所谓陷阱，就是它不是你认为的那样，这种认知误差可能让你的软件留下隐藏bug。刚好timer就有3个陷阱，我们会讲

1）reset的陷阱和

2）通道的陷阱，

3）stop的陷阱与reset的陷阱类似，自己探索吧。

下面话不多说了，来一起看看详细的介绍吧

reset的陷阱在哪

timer.reset()函数的返回值是bool类型，我们看一个问题三连：

• 它的返回值代表什么呢？
• 我们想要的成功是什么？
• 失败是什么？

成功：一段时间之后定时器超时，收到超时事件。

失败：成功的反面，我们收不到那个事件。对于失败，我们应当做些什么，确保我们的定时器发挥作用。

reset的返回值是不是这个意思？

通过查看文档和实现，timer.reset()的返回值并不符合我们的预期，这就是误差。它的返回值不代表重设定时器成功或失败，而是在表达定时器在重设前的状态：

• 当timer已经停止或者超时，返回false。
• 当定时器未超时时，返回true。

所以，当reset返回false时，我们并不能认为一段时间之后，超时不会到来，实际上可能会到来，定时器已经生效了。

跳过陷阱，再遇陷阱

如何跳过前面的陷阱，让reset符合我们的预期功能呢？直接忽视reset的返回值好了，它不能帮助你达到预期的效果。

真正的陷阱是timer的通道，它和我们预期的成功、失败密切相关。我们所期望的定时器设置失败，通常只和通道有关：设置定时器前，定时器的通道timer.c中是否已经有数据。

• 如果有，我们设置的定时器失败了，我们可能读到不正确的超时事件。
• 如果没有，我们设置的定时器成功了，我们在设定的时间得到超时事件。

接下来解释为何失败只与通道中是否存在超时事件有关。

定时器的缓存通道大小只为1，无法多存放超时事件，看源码。

// newtimer creates a new timer that will send
// the current time on its channel after at least duration d.
func newtimer(d duration) *timer {
 c := make(chan time, 1) // 缓存通道大小为1
 t := &timer{
  c: c,
  r: runtimetimer{
   when: when(d),
   f: sendtime,
   arg: c,
  },
 }
 starttimer(&t.r)
 return t
}

定时器创建后是单独运行的，超时后会向通道写入数据，你从通道中把数据读走。当前一次的超时数据没有被读取，而设置了新的定时器，然后去通道读数据，结果读到的是上次超时的超时事件，看似成功，实则失败，完全掉入陷阱。

跨越陷阱，确保成功

如果确保timer.reset()成功，得到我们想要的结果？timer.reset()前清空通道。

当业务场景简单时，没有必要主动清空通道。比如，处理流程是：设置1次定时器，处理一次定时器，中间无中断，下次reset前，通道必然是空的。

当业务场景复杂时，不确定通道是否为空，那就主动清除。

if len(timer.c) > 0{
 <-timer.c
}
timer.reset(time.second)

测试代码

package main

import (
 "fmt"
 "time"
)

// 不同情况下，timer.reset()的返回值
func test1() {
 fmt.println("第1个测试：reset返回值和什么有关？")
 tm := time.newtimer(time.second)
 defer tm.stop()

 quit := make(chan bool)

 // 退出事件
 go func() {
  time.sleep(3 * time.second)
  quit <- true
 }()

 // timer未超时，看reset的返回值
 if !tm.reset(time.second) {
  fmt.println("未超时，reset返回false")
 } else {
  fmt.println("未超时，reset返回true")
 }

 // 停止timer
 tm.stop()
 if !tm.reset(time.second) {
  fmt.println("停止timer，reset返回false")
 } else {
  fmt.println("停止timer，reset返回true")
 }

 // timer超时
 for {
  select {
  case <-quit:
   return

  case <-tm.c:
   if !tm.reset(time.second) {
    fmt.println("超时，reset返回false")
   } else {
    fmt.println("超时，reset返回true")
   }
  }
 }
}

func test2() {
 fmt.println("\n第2个测试:超时后，不读通道中的事件，可以reset成功吗？")
 sm2start := time.now()
 tm2 := time.newtimer(time.second)
 time.sleep(2 * time.second)
 fmt.printf("reset前通道中事件的数量:%d\n", len(tm2.c))
 if !tm2.reset(time.second) {
  fmt.println("不读通道数据，reset返回false")
 } else {
  fmt.println("不读通道数据，reset返回true")
 }
 fmt.printf("reset后通道中事件的数量:%d\n", len(tm2.c))

 select {
 case t := <-tm2.c:
  fmt.printf("tm2开始的时间: %v\n", sm2start.unix())
  fmt.printf("通道中事件的时间：%v\n", t.unix())
  if t.sub(sm2start) <= time.second+time.millisecond {
   fmt.println("通道中的时间是重新设置sm2前的时间，即第一次超时的时间，所以第二次reset失败了")
  }
 }

 fmt.printf("读通道后，其中事件的数量:%d\n", len(tm2.c))
 tm2.reset(time.second)
 fmt.printf("再次reset后，通道中事件的数量:%d\n", len(tm2.c))
 time.sleep(2 * time.second)
 fmt.printf("超时后通道中事件的数量:%d\n", len(tm2.c))
}

func test3() {
 fmt.println("\n第3个测试：reset前清空通道，尽可能通畅")
 smstart := time.now()
 tm := time.newtimer(time.second)
 time.sleep(2 * time.second)
 if len(tm.c) > 0 {
  <-tm.c
 }
 tm.reset(time.second)

 // 超时
 t := <-tm.c
 fmt.printf("tm开始的时间: %v\n", smstart.unix())
 fmt.printf("通道中事件的时间：%v\n", t.unix())
 if t.sub(smstart) <= time.second+time.millisecond {
  fmt.println("通道中的时间是重新设置sm前的时间，即第一次超时的时间，所以第二次reset失败了")
 } else {
  fmt.println("通道中的时间是重新设置sm后的时间，reset成功了")
 }
}

func main() {
 test1()
 test2()
 test3()
}

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。