Timer

Timer 是一种单一事件定时器，就是说 Timer 只执行一次就会结束。

创建：

time.NewTimer(d Duration) ：创建一个 timer

• 参数为等待事件

• 时间到来后立即触发一个事件

源码包 src/time/sleep.go:Timer 定义了 Timer 数据结构：

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

Timer 对外仅暴露了一个 channel，当指定时间到来就会往该 channel 中写入系统时间，即一个事件。

timer 使用

设定超时时间

比如在一个连接中等待数据，设定一个超时时间，当时间到来还是没有数据获取到，则为超时。

func WaitChannel(conn <-chan string) bool {  timer := time.NewTimer(3 * time.Second)
  select {  case <- conn:    timer.Stop()    return true  case <- timer.C: //超时    fmt.Println("WaitChannel timeout")    return false  }}

如上示例中，select 语句轮询 conn 和 timer.C 两个管道，timer 会在 3s 后向 timer.C 写入数据，如果 3s 内 conn 还没有数据，则会判断为超时。

延迟执行方法

有时我们希望某个方法在今后的某个时刻执行：

func DelayFunction() {  timer := time.NewTimer(5 * time.Second)    select {  case <- time.C    fmt.Println("Delayed 5s，...")  }}

DelayFunction()会一直等待 timer 的事件到来才会执行后面的方法(打印)。

Timer 对外接口

创建定时器

func NewTimer(d Duration) *Timer :

• 指定一个时间即可创建一个 Timer，Timer 一经创建便开始计时，不需要额外的启动。

• 创建 Timer 意味着把一个计时任务交给系统守护协程，该协程管理着所有的 Timer，当 Timer 的时间到达后向 Timer 的管道中发送当前的时间作为事件。

停止定时器

func (t *Timer) Stop() bool ：

• Timer 创建后可随时停止

• 返回值表示是否超时：

• true : 定时器未超时，后续不会再有事件发送

• false : 定时器超时后停止

重置定时器

func (t *Timer) Reset(d Duration) bool:

• 已经过期的定时器或已经停止的定时器，可以通过重置来重新激活

• 重置的动作实质上是先停掉定时器，再启动。其返回值也即停掉计时器的返回值。

简单接口

After()

有时我们就是想等指定的时间，没有需求提前停止定时器，也没有需求复用该定时器，那么可以使用匿名的定时器：

func AfterDemo(){  log.Println(time.Now)  <- time.After(1 * time.Second)  log.Println(time.Now())}

打印时间间隔为 1s，实际还是一个定时器，但代码变得更简洁。

AfterFunc()

我们可以使用 AfterFunc 更加简洁的实现延迟一个方法的调用：

func AfterFunc(d Duration, f func()) *Timer

示例：

func AfterFuncDemo() {  log.Println("AfterFuncDemo start", time.Now())  time.AfterFunc(1 * time.Second, func(){    log.Println("AfterFuncDemo end", time.Now())  })    time.Sleep(2 * time.Second) //等待协程退出}

• AfterFuncDemo()中先打印一个时间，然后使用 AfterFunc 启动一个定时器，并指定定时器结束时执行一个方法打印结束时间。

• time.AfterFunc()是异步执行的，所以需要在函数最后 sleep 等待指定的协程退出，否则可能函数结束时协程还未执行。

Ticker

Ticker 是周期性定时器，即周期性的触发一个事件。其数据结构和 Timer 完全一致：

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

在创建 Ticker 时会指定一个时间，作为事件触发的周期。这也是 Ticker 与 Timer 的最主要的区别。

Ticker 使用

定时任务

示例，每隔 1s 记录一次日志：

func TickerDemo() {  ticker := time.NewTicker(1 * time.Second)  defer ticker.Stop()    for range ticker.C {    log.Println("ticker...")  }}

for range ticker.C 会持续从管道中获取事件，收到事件后打印一行日志，如果管道中没有数据会阻塞等待事件，由于 ticker 会周期性的向管道中写入事件，所以上述程序会周期性的打印日志。

Ticker 对外接口

创建定时器

func NewTicker(d Durtion) * Ticker :

• 参数 d 为定时器事件触发的周期。

停止定时器

func (t * Ticker) Stop() :

• 该方法会停止计时，意味着不会向定时器的管道中写入事件，但管道并不会被关闭。管道在使用完成后，生命周期结束后会自动释放。

• Ticker 在使用完后务必要释放，否则会产生资源泄露，进而会持续消耗 CPU 资源，最后会把 CPU 耗尽。

简单接口

如果我们需要一个定时轮询任务，可以使用一个简单的 Tick 函数来获取定时器的管道，函数原型如下：

func TIck(d Durtion) <-chan Time :

• 这个函数内部实际还是创建一个 Ticker，但并不会返回出来，所以没有手段来停止该 Ticker。所以，一定要考虑具体的使用场景。

错误示例

func WorngTicker() {  for {    select {    case <- time.Tick(1 * time.Second)      log.Println("资源泄露")    }  }}

如上错误示例，select 每次检测 case 语句时都会创建一个定时器，for 循环又会不断的执行 select 语句，所以系统里会有越来越多的定时器不断的消耗 CPU 资源，最终 CPU 会被耗尽。

正确用法：

func demo(t interface{}) {    for {        select {        case <-t.(*time.Ticker).C:            println("1s timer")        }    }}
func main() {    t := time.NewTicker(time.Second * 1)    go demo(t)    select {}}