Go · time 与定时器

场景 1 · 消息网关 4 天涨 2.3GB: 循环超时改 NewTimer+Reset

每条消息的 for-select 里各建一个 time.After, 未到期 Timer 在堆里堆积; pprof heap 差分显示 time.Timer 对象占新增 71%:

// 症状: 内存 4 天涨 2.3GB; 修复后 72h RSS 平直
t := time.NewTimer(idleTimeout)
defer t.Stop()                            // 用完必须出堆
for msg := range inbox {
    select {
    case resp := <-pending:
        handle(msg, resp)
        if !t.Stop() {                          // 停掉计时的旧值
            select { case <-t.C: default: }     // drain 清残留
        }
        t.Reset(idleTimeout)                    // 复用同一个堆节点
    case <-t.C:
        return                                  // 真空闲超时才退出
    }
}

峰值在堆 Timer 从 ~200 万个降到 1 个; 换 Go 1.23+ 也能自愈, 但复用写法全版本安全。

场景 2 · 下游报表接口固定 50 QPS 打点

压测下游限流阈值, Ticker 比 time.Sleep 循环更贴"恒定速率", 且必须监听取消:

func pump(ctx context.Context, out chan<- Req) {
    tk := time.NewTicker(time.Second / 50)      // 20ms 一个间隔
    defer tk.Stop()                         // 不 Stop = 堆常驻泄漏
    for {
        select {
        case <-tk.C:
            select {
            case out <- nextReq():
            case <-ctx.Done(): return        // 满了也要听取消
            }
        case <-ctx.Done():
            return
        }
    }
}

场景 3 · 优雅退出: 完成 / 外部强杀 / 兜底超时三路 select

K8s terminationGracePeriod 只有 30s, 排空在途任务既要等得了也要走得了:

func gracefulShutdown(ctx context.Context, srv *Server) error {
    done := make(chan error, 1)
    go func() { done <- srv.DrainTasks() }()      // 排空在途任务
    select {
    case err := <-done:                          // 正常收完
        return err
    case <-ctx.Done():                           // 外部又发了强杀
        return ctx.Err()
    case <-time.After(15 * time.Second):         // 兜底: 给强杀留余量
        return ErrShutdownTimeout
    }
}

场景 4 · cron 每 5 分钟一轮, 但上一轮要跑 8 分钟: 防重叠

两轮并发写同一张对账表会产生重复行; 用原子标志"上一轮没跑完就跳过":

var running atomic.Bool                     // CAS 抢占, 不排队
func run() {
    if !running.CompareAndSwap(false, true) {
        log.Print("上一轮未结束, 跳过本轮")          // 宁可少跑不可重叠
        return
    }
    defer running.Store(false)
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
    defer cancel()                             // 超时硬停, 防连环重叠
    syncAllAccounts(ctx)
}

多实例部署时 atomic.Bool 只管单进程, 跨实例要换分布式锁 (Redis SETNX 或 DB 唯一键)。

场景 5 · 时区转换服务: UTC 存储 + 用户时区展示

全球站点的活动时间, 存储层混用本地时区是事故之源:

import _ "time/tzdata"                     // scratch 容器无系统时区表时兜底
loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil { return err }
// 存储约定: DB 一律存 UTC; 展示层才转用户时区
utc := t.UTC().Format(time.RFC3339)
db.Exec("INSERT INTO events(at) VALUES (?)", utc)
// 展示: 同一时刻, 按用户 profile 的时区渲染
userT := t.In(loc)                              // 时刻不变, 只换坐标
fmt.Println(userT.Format("2006-01-02 15:04:05"))

场景 6 · 布局速记与 API 时间字段约定

新人最常犯: 把 strftime 的 yyyy-MM-dd 抄进来, 输出原样字符串还以为是对的:

// 参考时间点: 1月2日 15:04:05 2006年 → 1 2 3 4 5 6
ref := time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC)
ref.Format("2006-01-02 15:04:05")       // 2006-01-02 15:04:05
ref.Format("01/02 03:04:05PM '06 -0700") // 01/02 03:04:05PM '06 +0000
ref.Format("yyyy-MM-dd")                // 字面输出 yyyy-MM-dd !
// API 对外统一 RFC3339: 带时区, 跨语言无歧义
t, err := time.Parse(time.RFC3339, "2026-09-26T10:00:00+08:00")

场景 7 · deadline 驱动的分级降级

搜索网关拿到剩余预算后决定走哪条链路 —— 时间本身就是路由依据:

func route(ctx context.Context) (Plan, error) {
    left := time.Until(deadline)                // Duration, 单调钟测得
    switch {
    case left <= 0:
        return nil, ErrDeadlinePassed           // 已过期: 直接拒
    case left < 300*time.Millisecond:
        return cacheOnly(ctx)                   // 只剩零头: 走缓存
    case left < 2*time.Second:
        return localIndex(ctx)                  // 本地倒排索引
    default:
        return fullSearch(ctx)                  // 余量充足: 全量检索
    }
}

场景 8 · 月度账单的 AddDate 月末溢出修复

1月31日开通的会员, 2月没有 31 号, AddDate 直接溢出到 3月3日导致 2 月账单丢失:

// 坑: AddDate 按日历"进位", 1.31 + 1 月 = 3.3
start := time.Date(2026, 1, 31, 0, 0, 0, 0, loc)
fmt.Println(start.AddDate(0, 1, 0).Format("2006-01-02")) // 2026-03-03
// 修复: 天数取 min(开通日, 当月最后一天)
func nextBill(t time.Time) time.Time {
    y, m, _ := t.Date()
    last := time.Date(y, m+1, 1, 0, 0, 0, 0, t.Location()).AddDate(0, 0, -1)
    day := min(t.Day(), last.Day())             // 月末封顶: 2月 → 28/29
    return time.Date(y, m+1, day, 0, 0, 0, 0, t.Location())
}

场景 9 · Ticker 调度延迟监控: 期望 tick vs 实际 tick

GC 停顿或机器超卖会让"每 100ms 一次"变成 170ms, 漂移打点帮你抓到毛刺:

tk := time.NewTicker(100 * time.Millisecond)
defer tk.Stop()
var last = time.Now()
for range tk.C {
    now := time.Now()
    lag := now.Sub(last) - 100*time.Millisecond // 间隔外的部分
    if lag > 50*time.Millisecond {
        schedLag.Observe(lag.Seconds())          // 上报调度/GC 毛刺
    }
    last = now                                  // 用实际时刻: 不累积漂移
}

注意别用"固定 next = start.Add(k*d)"重对齐 —— 那是整点对齐的需求, 普通监控会掩盖真实延迟。

场景 10 · mock 时间注入: 24 小时过期测试秒级跑完

token 24h 过期逻辑, 真等一天不可接受; 把 now 抽成函数依赖:

type Clock struct{ now func() time.Time }
func NewClock() *Clock { return &Clock{now: time.Now} }
func (c *Clock) Now() time.Time { return c.now() }
// 测试里拨快时钟: 不用真等 24h, 秒级跑完
func TestTokenExpiry(t *testing.T) {
    base := time.Date(2026, 9, 26, 0, 0, 0, 0, time.UTC)
    c := &Clock{now: func() time.Time { return base.Add(25 * time.Hour) }}
    if !tokenExpired(c, issuedAt(base)) {       // 25h > 24h 有效期
        t.Fatal("token 应已过期")
    }
}