Go: Ticker

This content originally appeared on DEV Community and was authored by leon

time.Ticker 是 Go 语言标准库 time 包中一个强大的工具，用于实现周期性的任务。它以固定的时间间隔向一个通道发送事件，非常适合用于轮询、定时刷新缓存、心跳检测等多种场景。然而，不当的使用也可能导致 goroutine 泄漏和程序性能问题。本文将全面总结 time.Ticker 的使用技巧，从基础用法到高级模式，帮助您高效、安全地在项目中使用它。

1. 基础用法：创建和接收事件

创建一个 Ticker 非常简单，只需调用 time.NewTicker() 并传入一个 time.Duration 类型的参数作为时间间隔。

Go

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个每秒触发一次的 ticker
    ticker := time.NewTicker(1 * time.Second)
    defer ticker.Stop() // 确保在不需要时停止 ticker

    done := make(chan bool)

    go func() {
        for {
            select {
            case <-done:
                return
            case t := <-ticker.C:
                fmt.Println("Tick at", t)
            }
        }
    }()

    // 运行一段时间后停止
    time.Sleep(5 * time.Second)
    done <- true
    fmt.Println("Ticker stopped")
}

核心要点:

time.NewTicker(duration) 返回一个 time.Ticker 对象。
ticker.C 是一个通道 (<-chan time.Time)，会按设定的时间间隔接收到当前时间。
必须调用 ticker.Stop() 来释放相关资源。通常使用 defer 语句来确保在函数退出时执行。

2. 安全停止 Ticker：避免 Goroutine 泄漏

忘记调用 ticker.Stop() 是一个常见的错误，这会导致底层的 goroutine 无法被垃圾回收，从而造成 goroutine 泄漏。特别是在一个长期运行的程序中，这会逐渐消耗系统资源。

优雅关闭模式 (Graceful Shutdown)

在实际应用中，我们常常需要在程序退出时，或者某个模块不再需要时，优雅地停止正在运行的 ticker。这通常通过一个额外的 done 或 quit 通道来实现。

Go

package main

import (
    "fmt"
    "time"
)

func worker(stop chan bool) {
    ticker := time.NewTicker(1 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            fmt.Println("Doing periodic work...")
        case <-stop:
            fmt.Println("Worker stopping...")
            return
        }
    }
}

func main() {
    stop := make(chan bool)
    go worker(stop)

    time.Sleep(3 * time.Second)
    stop <- true // 发送停止信号
    time.Sleep(1 * time.Second) // 等待 worker 退出
    fmt.Println("Main finished")
}

这种 select 结构允许 goroutine 同时监听 ticker 事件和停止信号，实现了对 goroutine 生命周期的精确控制。

3. Ticker 与 `time.Sleep` 的对决

初学者可能会使用 for 循环配合 time.Sleep() 来实现周期性任务。然而，time.Ticker 在精确性和效率上通常更胜一筹。

特性	`time.Ticker`	`for` + `time.Sleep(d)`
精确性	高。Ticker 会自动调整下一次触发的时间，以弥补任务执行所花费的时间，尽可能保证平均间隔为 `d`。	低。实际的执行间隔是 `任务执行时间 + d`，会导致周期逐渐漂移。
资源使用	较为高效，底层由 Go runtime 的定时器统一管理。	简单直接，但不够精确。
控制	可以通过 `Stop()` 和 `Reset()` 进行灵活控制。	只能在循环中通过 `break` 或 `return` 退出。

结论： 对于需要精确周期的任务，强烈推荐使用 time.Ticker。time.Sleep 更适用于简单的、对周期精度要求不高的延时场景。

4. 应对慢消费者 (Slow Receiver)

如果接收 ticker.C 的任务执行时间超过了 ticker 的间隔时间，会发生什么？

time.Ticker 的内部通道只有一个缓冲区。如果上一个 tick 还没有被消费，而新的 tick 又到了，Ticker 会丢弃这个新的 tick，等待消费者处理完当前 tick 后再发送下一个。这可以防止 tick 在通道中无限堆积，但也意味着任务的执行频率会降低。

示例：

Go

ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()

for range ticker.C {
    fmt.Println("Tick!")
    time.Sleep(2 * time.Second) // 任务耗时超过了 ticker 间隔
}
// 输出会是每 2 秒一个 "Tick!"，而不是每秒一个

应对策略：

优化任务性能：从根本上减少每次任务的执行时间。
解耦：如果任务确实耗时，可以考虑将任务放入一个工作池 (worker pool) 中异步执行，让 ticker 的接收者只负责分发任务，避免阻塞。

5. 动态调整 Ticker 间隔

在某些场景下，我们可能需要根据程序的运行状态动态调整定时任务的频率。这时可以使用 ticker.Reset() 方法。

ticker.Reset(newDuration) 会停止当前的 ticker，并将其周期重置为新的时长。下一个 tick 会在 newDuration 之后到达。

Go

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(3 * time.Second)
    defer ticker.Stop()

    go func() {
        for t := range ticker.C {
            fmt.Println("Tick at", t)
        }
    }()

    fmt.Println("Ticker started with 3s interval.")
    time.Sleep(7 * time.Second)

    // 将间隔重置为 1 秒
    ticker.Reset(1 * time.Second)
    fmt.Println("Ticker interval reset to 1s.")

    time.Sleep(5 * time.Second)
}

6. Go 1.23 的重要变化：自动垃圾回收

在 Go 1.23 之前，如果忘记调用 ticker.Stop()，Ticker 对象将永远不会被垃圾回收，导致资源泄漏。

从 Go 1.23 开始，Go 的垃圾回收器变得更加智能，能够回收未被引用的、且未被停止的 Ticker。这意味着即使忘记调用 Stop()，也不再会导致永久的资源泄漏。

尽管如此，最佳实践仍然是：

显式调用 Stop()：这使得代码意图更加清晰，表明你已经完成了对这个 Ticker 的使用。
在不再需要 Ticker 时立即停止它，可以更早地释放资源，而不是等待 GC。

7. 常见使用场景

心跳检测：客户端或服务器定时发送心跳包以维持连接。
数据轮询：定时从数据库、API 或其他数据源拉取更新。
缓存刷新：定期清理或更新内存中的缓存数据。
监控和度量：周期性地收集系统性能指标。
超时控制：结合 select 语句，为某个操作设置一个周期性的检查点。

总结

time.Ticker 是 Go 并发编程中不可或缺的工具。掌握其正确的使用方法，特别是优雅地停止它，是编写健壮、可维护的 Go 程序的关键。

核心技巧回顾：

创建与停止：使用 time.NewTicker() 创建，并用 defer ticker.Stop() 确保释放。
优雅关闭：结合 select 和一个额外的 done 通道来安全地终止 goroutine。
精确周期：优先选择 Ticker 而不是 time.Sleep 来保证周期的准确性。
注意慢消费：理解慢消费会导致 tick 被丢弃，并据此设计你的任务逻辑。
动态调整：使用 ticker.Reset() 灵活改变任务频率。
了解版本差异：知晓 Go 1.23 在 GC 方面的改进，但仍坚持显式调用 Stop() 的好习惯。

通过遵循这些技巧，你可以充满信心地在你的 Go 项目中发挥 time.Ticker 的最大效用。