当前位置：首页 > 文章列表 > Golang > Go教程 > go语言Timer计时器的用法示例详解

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

来源：脚本之家 2023-01-07 11:52:18 0浏览收藏

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《go语言Timer计时器的用法示例详解》，聊聊计时器、goTimer，我们一起来看看吧！

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

package main
import "time"
import "fmt"
func main() {
//新建计时器，两秒以后触发，go触发计时器的方法比较特别，就是在计时器的channel中发送值
timer1 := time.NewTimer(time.Second * 2)
//此处在等待channel中的信号，执行此段代码时会阻塞两秒


<p>代码解读见注释。</p>
<p>最终输出结果为：</p>
<blockquote>
<p>Timer 1 expired</p>
<p>Timer 2 stopped</p>
</blockquote>
<p>因为Timer 2的处理线程在等到信号前已经被停止掉了，所以会打印出Timer 2 stopped而不是Timer 2 expired</p>
<p>附录：下面看下Go语言计时器的使用详解</p>
<p>
<meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><span style="color: #ff0000"><strong>Go语言计时器</strong></span></p>
<p><code>Go</code>语言的标准库里提供两种类型的计时器<code>Timer</code>和<code>Ticker</code>。<code>Timer</code>经过指定的<code>duration</code>时间后被触发，往自己的时间<code>channel</code>发送当前时间，此后<code>Timer</code>不再计时。<code>Ticker</code>则是每隔<code>duration</code>时间都会把当前时间点发送给自己的时间<code>channel</code>，利用计时器的时间<code>channel</code>可以实现很多与计时相关的功能。</p>
<p>文章主要涉及如下内容：</p>

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 

<p><code>Timer.C</code>和<code>Ticker.C</code>就是计时器中的时间<code>channel</code>，接下来我们看一下怎么使用这两种计时器，以及使用时要注意的地方。</p>
<p><span style="color: #ff0000"><strong>Timer计时器</strong></span></p>
<p><code>time.Timer</code>计时器必须通过 <code>time.NewTimer</code>、<code>time.AfterFunc</code>或者 <code>time.After</code>函数创建。当计时器失效时，失效的时间就会被发送给计时器持有的 <code>channel</code>，订阅 <code>channel</code>的 <code>goroutine</code>会收到计时器失效的时间。</p>
<p>通过定时器<code>Timer</code>用户可以定义自己的超时逻辑，尤其是在应对使用<code>select</code>处理多个<code>channel</code>的超时、单<code>channel</code>读写的超时等情形时尤为方便。<code>Timer</code>常见的使用方法如下：</p>

<pre class="brush:plain;">
//使用time.AfterFunc：

t := time.AfterFunc(d, f)

//使用time.After：
select {
 case m := 

<p><code>time.AfterFunc</code>这种方式创建的<code>Timer</code>，在到达超时时间后会在单独的<code>goroutine</code>里执行函数<code>f</code>。</p>

<pre class="brush:plain;">
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) 

<p><code>sendTime</code>将当前时间发送到<code>Timer</code>的时间<code>channel</code>中。那么这个动作不会阻塞<code>timerproc</code>的执行么？答案是不会，原因是<code>NewTimer</code>创建的是一个带缓冲的<code>channel</code>所以无论<code>Timer.C</code>这个<code>channel</code>有没有接收方<code>sendTime</code>都可以非阻塞的将当前时间发送给<code>Timer.C</code>，而且<code>sendTime</code>中还加了双保险：通过<code>select</code>判断<code>Timer.C</code>的<code>Buffer</code>是否已满，一旦满了，会直接退出，依然不会阻塞。</p>
<p><code>Timer</code>的<code>Stop</code>方法可以阻止计时器触发，调用<code>Stop</code>方法成功停止了计时器的触发将会返回<code>true</code>，如果计时器已经过期了或者已经被<code>Stop</code>停止过了，再次调用<code>Stop</code>方法将会返回<code>false</code>。</p>
<p><code>Go</code>运行时将所有计时器维护在一个最小堆<code>Min Heap</code>中，<code>Stop</code>一个计时器就是从堆中删除该计时器。</p>
<p><span style="color: #ff0000"><strong>Ticker计时器</strong></span></p>
<p><code>Ticker</code>可以周期性地触发时间事件，每次到达指定的时间间隔后都会触发事件。</p>
<p><code>time.Ticker</code>需要通过<code>time.NewTicker</code>或者<code>time.Tick</code>创建。</p>

<pre class="brush:plain;">
// 使用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 

<p><span style="color: #ff0000"><strong>Reset计时器时要注意的问题</strong></span></p>
<p>关于<code>Reset</code>的使用建议，文档里的描述是：</p>
<p>重置计时器时必须注意不要与当前计时器到期发送时间到t.C的操作产生竞争。如果程序已经从t.C接收到值，则计时器是已知的已过期，并且t.Reset可以直接使用。如果程序尚未从t.C接收值，计时器必须先被停止，并且-如果使用t.Stop时报告计时器已过期，那么请排空其通道中值。</p>
<p>例如：</p>

<pre class="brush:plain;">
if !t.Stop() {
 

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

<pre class="brush:plain;">
func main() {
 c := make(chan bool)

 go func() {
 for i := 0; i 

<p>程序的输出如下：</p>
<blockquote>
<p>2020-05-13 12:49:48.90292 +0800 CST m=+1.004554120 :recv false. continue<br>
2020-05-13 12:49:49.906087 +0800 CST m=+2.007748042 :recv false. continue<br>
2020-05-13 12:49:50.910208 +0800 CST m=+3.011892138 :recv false. continue<br>
2020-05-13 12:49:51.914291 +0800 CST m=+4.015997373 :recv false. continue<br>
2020-05-13 12:49:52.916762 +0800 CST m=+5.018489240 :recv false. continue<br>
2020-05-13 12:49:53.920384 +0800 CST m=+6.022129708 :recv true. return</p>
</blockquote>
<p>目前来看没什么问题，使用Reset重置计时器也起作用了，接下来我们对<code>producer goroutin</code>做一些更改，我们把<code>producer goroutine</code>里每秒发送值的逻辑改成每<code>6</code>秒发送值，而<code>consumer gouroutine</code>里和计时器还是<code>5</code>秒就到期。</p>

<pre class="brush:plain;">
// producer
 go func() {
 for i := 0; i 

<p>再次运行会发现程序发生了<code>deadlock</code>在第一次报告计时器过期后直接阻塞住了：</p>
<blockquote>
<p>2020-05-13 13:09:11.166976 +0800 CST m=+5.005266022 :timer expired</p>
</blockquote>
<p>那程序是在哪阻塞住的呢？对就是在抽干<code>timer.C</code>通道时阻塞住了（英文叫做drain channel比喻成流干管道里的水，在程序里就是让<code>timer.C</code>管道中不再存在未接收的值)。</p>
<p><code>producer goroutine</code>的发送行为发生了变化，<code>comsumer goroutine</code>在收到第一个数据前有了一次计时器过期的事件，<code>for</code>循环进行一下次循环。这时<code>timer.Stop</code>函数返回的不再是<code>true</code>，而是<code>false</code>，因为计时器已经过期了，上面提到的维护着所有活跃计时器的最小堆中已经不包含该计时器了。而此时<code>timer.C</code>中并没有数据，接下来用于<code>drain channel</code>的代码会将<code>consumer goroutine</code>阻塞住。</p>
<p>这种情况，我们应该直接<code>Reset</code>计时器，而不用显式<code>drain channel</code>。如何将这两种情形合二为一呢？我们可以利用一个<code>select</code>来包裹<code>drain channel</code>的操作，这样无论<code>channel</code>中是否有数据，<code>drain</code>都不会阻塞住。</p>

<pre class="brush:plain;">
//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 

<p>运行修改后的程序，发现程序不会被阻塞住，能正常进行通道读取，读取到<code>true</code>值后会自行退出。输出结果如下：</p>
<blockquote>
<p>2020-05-13 13:25:08.412679 +0800 CST m=+5.005475546 :timer expired<br>
2020-05-13 13:25:09.409249 +0800 CST m=+6.002037341 :recv false. continue<br>
2020-05-13 13:25:14.412282 +0800 CST m=+11.005029547 :timer expired<br>
2020-05-13 13:25:15.414482 +0800 CST m=+12.007221569 :recv false. continue<br>
2020-05-13 13:25:20.416826 +0800 CST m=+17.009524859 :timer expired<br>
2020-05-13 13:25:21.418555 +0800 CST m=+18.011245687 :recv false. continue<br>
2020-05-13 13:25:26.42388 +0800 CST m=+23.016530193 :timer expired<br>
2020-05-13 13:25:27.42294 +0800 CST m=+24.015582511 :recv false. continue<br>
2020-05-13 13:25:32.425666 +0800 CST m=+29.018267054 :timer expired<br>
2020-05-13 13:25:33.428189 +0800 CST m=+30.020782483 :recv false. continue<br>
2020-05-13 13:25:38.432428 +0800 CST m=+35.024980796 :timer expired<br>
2020-05-13 13:25:39.428343 +0800 CST m=+36.020887629 :recv true. return</p>
</blockquote>
<p><span style="color: #ff0000"><strong>总结</strong></span></p>
<p>以上比较详细地介绍了<code>Go</code>语言的计时器以及它们的使用方法和注意事项，总结一下有如下关键点：</p>