Golang中 Timer 无 buffer 的实现方式 是怎样的
原创
go
go
Go语言教程
2026年6月30日 13:20
陕西
在小说阅读器读本章
去阅读
线上服务偶发超时，我第一眼没去翻业务代码，先看了一眼 goroutine dump。
结果卡住的地方很眼熟：
select {
case <-workerDone:
return nil
case <-time.After(800 * time.Millisecond):
return errors.New(\"sync inventory timeout\")
}
这种代码平时没人怀疑。time.After、NewTimer、Reset，写 Go 的谁没用过。问题是 Go 1.23 之后，Timer 这块改过一次，而且改的不是表面 API，是通道语义。
以前 Timer 的 C，看着像个普通 <-chan time.Time，实际背后是一个容量为 1 的 channel。定时器到点，runtime 往里面塞一个时间值。你没来得及读，它就先放着。
这就埋了一个老坑：旧值。
比如下面这段代码，在 Go 1.22 及以前很容易出怪事：
func waitReply(reply <-chan string, timeout time.Duration) error {
t := time.NewTimer(timeout)
defer t.Stop()
for i := 0; i < 3; i++ {
t.Reset(timeout)
select {
case v := <-reply:
_ = v
return nil
case <-t.C:
return errors.New(\"reply timeout\")
}
}
return nil
}
这代码我第一眼就不太信，尤其是 Reset 前面没有处理旧的 timer 值。
老版本里，如果 timer 已经过期，t.C 里面可能已经塞了一个值。你后面 Reset 了，看着像重新计时，结果 select 立刻读到了上一次留下来的时间值。业务日志里就会出现这种东西：
request_id=817c wait_reply cost=2ms err=reply timeout
2ms 就 timeout，肯定不是下游慢，是自己计时器玩错了。
所以以前稳妥写法一般要这样：
func resetTimer(t *time.Timer, d time.Duration) {
if !t.Stop() {
select {
case <-t.C:
default:
}
}
t.Reset(d)
}
难看，但有用。
Go 1.23 之后，这块语义变了。Timer 的 channel 变成同步的，也就是无 buffer，容量表现为 0。官方文档里说得很直接：Go 1.23 开始，Timer 关联的 channel 是 synchronous，也就是 unbuffered，目的就是避免 Stop 或 Reset 返回之后还能读到旧 timer 值。
但这里有个细节，别只看一句“无 buffer”就以为源码里直接写了：
make(chan time.Time)
不是这么简单。
你去看 time.NewTimer，源码里仍然能看到：
c := make(chan Time, 1)
t := newTimer(when(d), 0, sendTime, c, syncTimer(c))
t.C = c
也就是说，表面上还是 make(chan Time, 1)，但它把 channel 通过 syncTimer(c) 交给了 runtime。runtime 走特殊路径，把这个 timer channel 按同步语义处理。官方源码里也能看到 syncTimer 会根据 GODEBUG=asynctimerchan 决定是否启用新路径。([Go开发][1])
这地方挺容易误判。
你要是只 grep make(chan Time, 1)，然后说“Go 1.23 Timer 还是有 buffer”，那就翻车了。真实表现看这个：
package main
import (
\"fmt\"
\"time\"
)
func main() {
t := time.NewTimer(time.Hour)
fmt.Println(\"cap:\", cap(t.C))
fmt.Println(\"len:\", len(t.C))
t.Stop()
}
Go 1.23 语义下，cap(t.C) 和 len(t.C) 都是 0。Go 官方 Wiki 也专门提了这个变化：以前 cap 是 1，len 可以用来看有没有值等待读取；Go 1.23 后，二者一直是 0。([Go开发][2])
所以以前这种代码也该扔了：
if len(t.C) > 0 {
<-t.C
}
这东西本来就有并发窗口，现在更是没意义。要探测 channel 能不能读，用非阻塞 select，不要拿 len 当监控指标。
select {
case <-t.C:
// drain old value, only needed when兼容老版本语义
default:
}
Timer 无 buffer 的关键，不是“到点就塞一个值进去等你拿”，而是“到点后要和接收方完成一次同步”。如果没有接收方，这个值不会像老版本那样稳定躺在 1 个槽位里，后续 Stop、Reset 也就可以更干净地切掉旧状态。
我自己现在写超时控制，一般分两种。
一次性的，直接 time.After，别装复杂：
func callPrice(ctx context.Context, sku string) error {
done := make(chan error, 1)
go func() {
done <- requestPriceCenter(ctx, sku)
}()
select {
case err := <-done:
return err
case <-time.After(900 * time.Millisecond):
return fmt.Errorf(\"price center timeout, sku=%s\", sku)
case <-ctx.Done():
return ctx.Err()
}
}
循环里反复用的，才会保留一个 Timer，不然不断创建也没必要：
func consumeWithIdle(ch <-chan []byte, idle time.Duration) error {
timer := time.NewTimer(idle)
defer timer.Stop()
for {
timer.Reset(idle)
select {
case msg, ok := <-ch:
if !ok {
return nil
}
if err := handleBinlogRow(msg); err != nil {
return err
}
case <-timer.C:
return errors.New(\"consumer idle too long\")
}
}
}
这段如果只跑 Go 1.23 及以后，不需要每次 Reset 前都 Stop + drain。因为 Reset 返回后，不会再收到旧配置对应的时间值。Stop 也是一样，返回之后再读 t.C，不会读到 Stop 之前残留的旧值。
不过生产上还有个坑：不是你本机 Go 版本是 1.23，就一定启用新语义。Go 官方说明过，新实现只在 go.mod 声明 go 1.23 或更高时启用；也可以用 GODEBUG=asynctimerchan=1 强制恢复旧语义。
所以排查 Timer 问题，我会先看这两个东西：
cat go.mod | grep '^go '
echo $GODEBUG
别一上来就怀疑 runtime。很多“升级了 Go 怎么还不对”的问题，最后都是 go.mod 还停在老版本，或者启动脚本里塞了兼容参数。
Timer 这次改动，解决的是一个非常烦人的历史包袱：旧值、Reset、Stop、drain 之间的竞态。无 buffer 只是表象，真正值钱的是语义收紧了。
以后看到这种代码：
if !t.Stop() {
<-t.C
}
t.Reset(d)
先别急着说它错。它可能是在兼容 Go 1.22 及以前。
但如果项目已经明确 Go 1.23+，go.mod 也跟上了，这类模板代码就可以删薄一点。Timer 不该成为业务代码里最难读的那几行。
版权声明
本站仅做备份收录，仅供研究与教学参考之用。
读者将信息用于其他用途的，全部法律及连带责任由读者自行承担，本站不承担任何责任。
评论