Go 定时器(Timer 与 Ticker)

用户下单 15 分钟未支付就自动取消订单,或者后台每隔 5 秒发送一次心跳检测,这类在指定时间后执行、或者每隔固定时间重复执行代码的机制,通常称为 “定时器”。

Go 语言的 time 包主要提供了 2 种定时器:一种是只触发一次的 “单次定时器(time.Timer)”,另一种是重复触发的 “周期性定时器(time.Ticker)”。相比无法中途唤醒的 time.Sleep(),这两种定时器都支持随时停止,用起来更加灵活。

单次定时器(time.Timer)

在 Go 语言中,我们可以使用 time.NewTimer() 函数创建一个单次定时器。创建出来的定时器结构体内部自带一个名为 C 的只读通道,当设定的时间到期时,系统会自动把当前时间发送到这个通道中。

语法:

// 创建单次定时器
timer := time.NewTimer(时间间隔)

// 阻塞等待定时器触发
<-timer.C

// 中途停止定时器
timer.Stop()

说明:

time.NewTimer() 接收一个大于 0 的时间间隔,比如 150 * time.Millisecond 或 2 * time.Second。创建好定时器后,最常用的操作有以下 2 个:

  • <-timer.C:等待定时器触发。在设定时间到达之前,读取 timer.C 会让当前协程停在原地等待。一旦时间到期,通道收到时间信号,程序就会继续往下执行。
  • timer.Stop():中途停止定时器。如果在定时器触发前成功将其停止,该方法会返回 true;如果定时器已经触发过或已经被停止过,则返回 false。

示例 1:创建单次定时器

package main

import (
    "fmt"
    "time"
)

func main() {
    timer := time.NewTimer(150 * time.Millisecond)
    fmt.Println("定时器已启动,等待 150 毫秒...")

    <-timer.C    // 阻塞等待定时时间到达
    fmt.Println("定时时间到,开始执行任务")
}

运行结果如下。

定时器已启动,等待 150 毫秒...
定时时间到,开始执行任务

分析:

time.NewTimer(150 * time.Millisecond) 表示创建一个 150 毫秒后触发的单次定时器。程序执行到 <-timer.C 时,由于设定的时间还没到,main() 函数就会停在这一行等待。

等到满 150 毫秒时,系统自动把当前时间发送到 timer.C 通道中,程序收到信号后便继续往下打印结果。如果我们还需要查看触发的具体时刻,也可以用变量接收它,写成 t := <-timer.C。

只是等待 150 毫秒,为什么不直接使用 time.Sleep() 呢?最大的区别就在于 time.Timer 支持中途调用 Stop() 取消定时。

比如我们开启了一个 1 秒的超时定时器,如果业务任务在 100 毫秒时就提前完成了,小伙伴们就可以配合 select 语句调用 timer.Stop() 把定时器关掉。下面我们通过一个例子来演示。

示例 2:中途停止定时器

package main

import (
    "fmt"
    "time"
)

func main() {
    timer := time.NewTimer(1 * time.Second)
    done := make(chan bool)

    // 模拟耗时 100 毫秒就提前完成的任务
    go func() {
        time.Sleep(100 * time.Millisecond)
        done <- true
    }()

    select {
    case <-done:
        if timer.Stop() {
            fmt.Println("任务提前完成,定时器已取消")
        }
    case <-timer.C:
        fmt.Println("定时时间到,触发超时处理")
    }
}

运行结果如下。

任务提前完成,定时器已取消

分析:

在这个例子中,定时器 timer 原本设定在 1 秒后触发,而子协程里的任务在 100 毫秒时就执行完毕并向 done 通道发送了信号。select 收到信号后走第 1 个分支,立即调用 timer.Stop() 取消尚未到期的定时器,并返回 true。

此外,如果需要复用同一个单次定时器重新倒计时,我们还可以调用 timer.Reset(新时间间隔) 来重置等待时长。从 Go 1.23 开始,官方已经优化了 Reset() 的底层行为,不再需要手动排空通道里可能残留的旧信号,不过在定时器停止或触发后再重置依然会让代码逻辑更清晰。

提示: 在配合 select 做超时控制时常用的 time.After(d),底层其实就是创建一个单次定时器并返回它的通道 C。如果我们只是做简单的单次超时等待、不需要中途调用 Stop() 取消定时,直接使用 time.After(d) 会更简洁。

周期性定时器(time.Ticker)

单次定时器 time.Timer 到期后只会触发一次。如果我们需要每隔一段固定时间就重复执行某项操作,比如定期刷新内存缓存、定时采集系统状态,就需要使用周期性定时器 time.Ticker。

我们可以使用 time.NewTicker() 函数创建周期性定时器。启动之后,它会按照设定的时间间隔,不断向内部的 ticker.C 通道发送时间信号,直到我们调用 ticker.Stop() 把它关停为止。

语法:

// 创建周期性定时器
ticker := time.NewTicker(时间间隔)
defer ticker.Stop()

// 循环接收周期信号
for range ticker.C {
    // 每隔指定时间执行一次
}

说明:

time.NewTicker(时间间隔) 的参数同样是一个大于 0 的时间长度。只要定时器还在运行,每隔一个时间间隔,ticker.C 通道就会收到一次当前时间信号。如果某次任务耗时超过了设定的间隔,Ticker 会自动丢弃中间来不及处理的信号,不会一次性连续补发多次把程序拖垮。

用完之后,我们应该配合 defer 语句调用 ticker.Stop() 及时停止定时器。需要注意的是,调用 ticker.Stop() 只会停止后续的时间信号发送,并不会关闭 ticker.C 通道。

为什么 Go 不顺便把 ticker.C 关掉呢?因为一旦通道被关闭,正在监听它的协程就会立刻读出一个零值时间,误以为定时时间又到了而错误触发业务。正因如此,for range ticker.C 不会因为调用了 Stop() 就自动结束,小伙伴们需要根据停止条件来选择合适的循环写法。

示例 3:按固定次数执行周期任务

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(100 * time.Millisecond)
    defer ticker.Stop()    // 函数退出前停止定时器

    count := 0
    for range ticker.C {
        count++
        fmt.Printf("第 %d 次执行定时任务\n", count)
        if count == 3 {
            break          // 执行满 3 次后跳出循环
        }
    }
    fmt.Println("周期任务已完成")
}

运行结果如下。

第 1 次执行定时任务
第 2 次执行定时任务
第 3 次执行定时任务
周期任务已完成

分析:

time.NewTicker(100 * time.Millisecond) 创建了一个每 100 毫秒触发一次的周期性定时器,下一行的 defer ticker.Stop() 则确保函数退出时自动关停它。

在 for range ticker.C 循环中,程序每隔 100 毫秒收到一次信号,累加执行满 3 次后通过 break 跳出循环。如果事先已经明确只需执行固定次数,我们也可以使用普通的计数循环来接收 <-ticker.C,下面 2 种方式是等价的。

// 方式 1
count := 0
for range ticker.C {
    count++
    fmt.Printf("第 %d 次执行定时任务\n", count)
    if count == 3 {
        break
    }
}

// 方式 2
for i := 1; i <= 3; i++ {
    <-ticker.C
    fmt.Printf("第 %d 次执行定时任务\n", i)
}

在实际开发中,周期任务通常需要持续运行,直到收到外部停止信号才结束。如果此时单写 for range ticker.C,一旦外部调用了 ticker.Stop(),循环就会因为等不到下一次信号而永久卡住。

遇到需要外部信号控制退出的场景,我们应该改用 for 循环配合 select,同时监听定时器通道和退出信号。下面来看一个例子。

示例 4:配合 select 停止周期任务

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(100 * time.Millisecond)
    defer ticker.Stop()

    // 250 毫秒后发出停止信号
    quit := time.After(250 * time.Millisecond)

    for {
        select {
        case <-ticker.C:
            fmt.Println("正在执行心跳检测...")
        case <-quit:
            fmt.Println("收到停止信号,结束周期任务")
            return
        }
    }
}

运行结果如下。

正在执行心跳检测...
正在执行心跳检测...
收到停止信号,结束周期任务

分析:

在这个例子中,ticker 每隔 100 毫秒触发一次心跳检测,而 quit 通道会在 250 毫秒时发出停止信号。因此在最初的 200 毫秒内,<-ticker.C 分支先后触发了 2 次。

等到满 250 毫秒时,<-quit 分支立即触发并执行 return 退出函数,随后 defer ticker.Stop() 会在函数结束前自动把定时器关停。

虽然从 Go 1.23 起不再被引用的定时器也能被垃圾回收器清理,但小伙伴们在平时写代码时依然应该养成用完 defer ticker.Stop() 的好习惯,这样既能兼容旧版本,也能避免定时器在后台白白占用系统资源。

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号