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
运行时内唯一的goroutine
timerproc
运行的。为了不阻塞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 语言计时器内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持!
下一篇: 公司新来的女同事