GO: 定时器NewTimer、NewTicker 和time.After

1、定时器（time.NewTimer）

Go语言的定时器实质是单向通道，time.Timer结构体类型中有一个time.Time类型的单向chan，源码（src/time/time.go）如下

type Timer struct {
    C <-chan Time
    r runtimeTimer
}

初始化 Timer 方法为NewTimer

示例

package main

import (
	"fmt"

	"time"
)

func main() {

	t := time.NewTimer(time.Second * 2)
	defer t.Stop()
	for {
		<-t.C
		fmt.Println("timer running...")
		// 需要重置Reset 使 t 重新开始计时
		t.Reset(time.Second * 2)
	}
}

输出

timer running...

这里使用NewTimer定时器需要t.Reset重置计数时间才能接着执行。如果注释 t.Reset(time.Second * 2)会导致通道堵塞，报fatal error: all goroutines are asleep - deadlock!错误。

同时需要注意 defer t.Stop()在这里并不会停止定时器。这是因为Stop会停止Timer，停止后，Timer不会再被发送，但是Stop不会关闭通道，防止读取通道发生错误。

如果想停止定时器，只能让go程序自动结束。

示例

package main

import (

"fmt"

"time"

)

func main() {

t := time.NewTimer(time.Second * 2)

ch := make(chan bool)
go func(t *time.Timer) {
	defer t.Stop()
	for {
		select {
		case <-t.C:
			fmt.Println("timer running....")
			// 需要重置Reset 使 t 重新开始计时
			t.Reset(time.Second * 2)
		case stop := <-ch:
			if stop {
				fmt.Println("timer Stop")
				return
			}
		}
	}
}(t)
time.Sleep(10 * time.Second)
ch <- true
close(ch)
time.Sleep(1 * time.Second)

2、定时期（NewTicker）

package main

import (
	"fmt"
	"time"
)

func main() {
		t := time.NewTicker(time.Second*2)
		defer t.Stop()
		for {
			<- t.C
			fmt.Println("Ticker running...")
		}		
}

结果

Ticker running...

ticker只要定义完成后，不需要其他操作就可以定时执行。

这里的defer t.Stop()和上面示例相似，也不会停止定时器，解决办法一样。

package main

import (
	"time"
	"fmt"
)

func main() {

	ticker := time.NewTicker(2 * time.Second)
	ch := make(chan bool)
	go func(ticker *time.Ticker) {
		defer ticker.Stop()
		for {
			select {
			case <-ticker.C:
				fmt.Println("Ticker running...")
			case stop := <-ch:
				if stop {
					fmt.Println("Ticker Stop")
					return
				}
			}
		}
	}(ticker)
	time.Sleep(10 * time.Second)
	ch <- true
	close(ch)
}

3、time.After

time.After()表示多长时间长的时候后返回一条time.Time类型的通道消息。但是在取出channel内容之前不阻塞，后续程序可以继续执行。

先看源码（src/time/sleep.go）

func After(d Duration) <-chan Time {
   return NewTimer(d).C
}

通过源码我们发现它返回的是一个NewTimer(d).C，其底层是用NewTimer实现的，所以如果考虑到效率低，可以直接自己调用NewTimer。

示例1

package main

import (
   "fmt"
   "time"
)

func main() {
   t := time.After(time.Second * 3)
   fmt.Printf("t type=%T\n", t)
   //阻塞3秒
   fmt.Println("t=", <-t)
}

运行结果

t type=<-chan time.Time

t= 2019-05-23 09:58:59.5103274 +0800 CST m=+3.008172101

先打印第一行，3s后打印第二行

基于time.After()特性可以配合select实现计时器

示例2

package main

import (
   "fmt"
   "time"
)

func main() {
   ch1 := make(chan int, 1)
   ch1 <- 1
   for {
      select {
      case e1 := <-ch1:
         //如果ch1通道成功读取数据，则执行该case处理语句
         fmt.Printf("1th case is selected. e1=%v\n", e1)
      case <-time.After(time.Second*2):
         fmt.Println("Timed out")
      }
   }

}

1th case is selected. e1=1

Timed out

select语句阻塞等待最先返回数据的channel`,如ch1通道成功读取数据，则先输出1th case is selected. e1=1，之后每隔2s输出 Timed out。