defer 已经不贵了,但有三种写法还在拖后腿

defer 已经不贵了,但有三种写法还在拖后腿
隔壁老康难度 ★★★☆☆ · 前置:runtime trace 里那些看不懂的条 | 一句话结论:单个 defer 的成本已经压到一纳秒上下,值得改的不是它,而是循环里反复创建闭包、以及 defer 数量在编译期定不下来的那几种写法。
1 | BenchmarkPlain-32 5000000 0.6364 ns/op |
第一次量完我盯着那两个数看了半天。
三行数摆在一起,第三条是我的预期,前两条不是。3.272 那一行正好在 1.527 上面又叠了一个差不多高的台阶,三个数排成一条直线,这个形状我在量之前就猜到了,老说法讲每个 defer 都要单独结算一次,那结果就该是等高的台阶,宽度也能估出来,一次函数调用的量级,跟一个空函数的开销差不多,因为那会儿每次注册都要走一遍运行时的那条路径,栈上记一条、地址记一条、退出时再倒着翻。我没猜到的是台阶的高度,0.89 纳秒,比我最早学到的说法小了一到两个数量级。那句话说 defer 慢,能不用就别用,尤其别放在热路径里,它在早年的 Go 上确实成立,那会儿每个 defer 都要往栈上记一条账,函数退出时再倒着翻一遍,开销跟一次函数调用差不多。后来编译器换了实现,代码直接在函数末尾展开,这笔账不记了,可那句话还在到处传。它跟很多过期的性能结论一样,出处是真的,只是截断在一台老编译器上。我入职第一年就把它抄进了自己的笔记,还照着它在两个服务里把 defer 换成了手写关闭,换完压测曲线一点没动,当时以为是没改到点子上,又跑去查别的原因,查了两天才绕回来。真正该被质疑的不是这句话的对错,是它的时效,一段在某个版本上成立的结论,编译器改一次实现就可能作废,可没人会在群里补一条撤回消息,于是它就一直活着,活成了一条不需要再验证的常识。
这话我自己也照着传了半年。
转折点在去年冬天,审一段批处理代码的时候。有人在循环里把 defer 全换成了手写关闭,改完压测曲线一点没动,他跑来问我为什么,我说的还是那套旧话。说完自己不太信,回家量了一晚上,量出来的就是上面这三行。所以这篇不是要证明 defer 快,是想把哪几种写法真的贵划出来,顺便把那句旧话的适用范围标一下,哪些版本之后它就不成立了。
环境是本机的 go1.27.2,windows/amd64,GOMAXPROCS 是 32,机器是 i9-14900HX,绝对值和你的机器不一样,但三个数之间的比例能照搬。
测法上有一处必须交代,函数体我加了 //go:noinline,不加的话编译器把整个调用内联掉,跑出来全是 0.5 纳秒上下。
第一遍我就栽在这儿,量完以为 defer 是免费的,还把截图发给了同事,被问了一句你加 noinline 了吗。
这三个数还有一个性质。第二个减第一个是 0.89 纳秒,第三个减第二个是 1.745 纳秒,差不多是两个 defer 的增量,每多挂一个 defer 就多付一次实打实的函数调用,没有额外的簿记成本摊在里头。要是还像早年那样往栈上记账,三个 defer 该比三个独立调用贵出一截,因为除了调用本身,还多了一次记账和一次倒序翻账。这条性质比绝对值有用,成本是按个数的线性函数,你能从一两个数把整条线推出来,也能反推一段两年前写的代码放到今天的编译器上大概值多少。
线性还有个副作用,它意味着一个 defer 很便宜和一层里挂十个 defer 很便宜是同一个结论,很多人只信了前一半。
现在测出来是纯线性,说明编译期就展开了,那 defer 剩下什么用?剩下写在哪儿。手写的话你得在每一条返回路径上都记得补一句,函数里有三个 return 就要写三遍,漏一处就是资源泄漏。
为省那 0.89 纳秒去手写,等于拿将来某次漏写的风险换一次测不出来的提速。这个交换我不做。
这笔账我算了两年才敢下这个结论。
它只写一遍,注册在开头。
真实场景里那点差距消失了
50 纳秒听着比 0.89 大得多,但它得跟谁比。
第二组基准换了场景,每次迭代打开一个文件再关掉,比较手写关闭和 defer 关闭。手写那一版是 3027 纳秒,defer 那一版是 3077 纳秒,差 50 纳秒,占整体的百分之一点六,两版的分配都是 208 字节三次,一模一样。
多出来的那点开销根本不涉及分配,也不涉及栈帧变大,纯粹是末尾多一条调用指令。
打开一个文件要走系统调用,要建一个 File 结构体,要准备缓冲区,这一套下来三千纳秒。
1 | BenchmarkDeferDirect-32 376234 3027 ns/op 208 B/op 3 allocs/op |
这个 50 里还带着误差。样本数就不一样,前者 376234 次,后者 385602 次,同样的时间跑出来的次数差了一万多,说明抖动就在这个量级。两组各重跑三次,两个数的先后换过,有时候反而是手写那版慢一点。隔一天又单独重测,defer 那版快了几纳秒。重测的数我没写进上面那张表,因为差值本身就落在抖动里,挑一个好看的方向写进来不老实。所以这一节只能得出一条结论,在这个粒度上选哪个,看代码好不好读。
带 defer 的版本把关闭紧挨着打开写,一眼能看到配对关系,手写的版本关闭在函数末尾,中间隔了十几行,得来回找。
循环里的 defer 是另一回事
真正贵的是第三种写法,在循环体里每次打开文件、建一个闭包、在闭包里 defer 关闭。这一版测出 28940 纳秒,是前两版的九倍多,分配 624 字节九次,也是三倍。九个分配里三个是打开文件本身的,另外六个来自那个闭包,每次循环建一个新的,捕获了手里的 File 指针,编译器没法把它放到栈上,只能分配到堆。这个差别不是 defer 自己的账,是闭包带着它一起搬了家,搬到堆上之后每一次都要等一次分配,等一次 GC 回来收,摊到 128720 次循环上就是那多出来的两万多纳秒。
1 | BenchmarkDeferLoop-32 128720 28940 ns/op 624 B/op 9 allocs/op |
这个结论我一开始没想到,这九倍里有多少是 defer 的账?几乎没有。一个 defer 不到一纳秒,就算一次操作里挂十来个,也才十来纳秒,占不到 28940 的零头。多出来的是闭包带来的六次额外分配,以及分配之后 GC 要处理的那些垃圾。
我本来以为这九倍里好歹有大半要记在 defer 头上,量完才发现 defer 只是碰巧跟闭包绑在了一起,它跟着闭包一起被分配到堆上,又被 GC 一起扫过,账记在闭包名下,它只是同乘了一趟车。解决办法是把循环体抽成一个函数,defer 写在函数体里,闭包就不需要了,defer 又能回到开放编码的形态。
这一步改到第三版才对,前面两版都在跟闭包的捕获范围较劲。
顺带的好处是错误处理也干净了,原来循环体里出错得往外跳,现在只要从那个函数 return err,上一层 continue,两个关注点分开,改动就有了边界。同一行 defer,放进循环为什么就变了?
什么时候它退回堆上记账
有三种情况会退回旧实现。一种是 defer 的数量在编译期定不下来,写在循环里、写在条件分支里、或者跟着某个变量走,编译器数不出到底几个,就只能往栈上记账,成本从纳秒级涨到几十纳秒,还要分配一块 defer 记录。判断标准很朴素,看它能不能在编译期变成一个确定的展开序列,能就便宜,不能就贵。
flowchart TD
A["这个 defer"] --> B{"数量在编译期数得出来吗"}
B -->|"数得出来"| C["开放编码:栈上记账,几纳秒"]
B -->|"数不出来"| D{"是 defer recover() 吗"}
D -->|"是"| E["runtime.deferproc:几十纳秒,外加一次分配"]
D -->|"不是"| F{"调用的方法要现算吗"}
F -->|"要"| E
F -->|"不要"| C
第二种这一条我没验证完。-S 只能告诉我这个函数最后走的是哪条路,说不清编译器为什么偏偏在那一次放弃了展开。我试过把一个只差一行的函数改回去,输出里的 deferreturn 就换成了 runtime.deferproc,可那两版在源码里的区别只是多包了一层括号。
我在源码里没找到能解释这一点的判断条件,只能从输出反推,现象先记在这儿。
参数在注册那一刻就定了
两种写法只差一对括号,行为完全不同。
性能之外有件事更重要,defer 的参数是在注册那一刻求值的,不是执行那一刻。我写过一段 x := 1 之后 defer fmt.Println(x) 再把 x 改成 2 的代码,打印出来是 1。这个行为经常被人当成坑,其实它是语义的一部分,因为 defer 后面那一串参数表达式就是普通表达式,按正常顺序求值,跟调用一个函数没有区别。
坑在闭包那一侧,defer func(){ fmt.Println(x) }() 打印的是 2,闭包捕获的是变量本身,不是当时的值。
我在 code review 里见过不止一次这种混淆,而且是那种改完之后测试还是绿的的混淆,因为测试里那段代码根本没被执行到。要传值就老老实实当参数传,要读最终值就用闭包。
三个返回值的函数要小心
带命名返回值的函数里,defer 能改返回值。func f()(n int){ n = 7; defer func(){ n = 8 }(); return n } 返回的是 8,不是 7。原因是 return n 分两步,先把 n 赋给返回值那个隐藏变量,再执行 defer,最后才真正返回。defer 改的是那个隐藏变量。这个特性能用,也容易出事,能用是因为它让出错时统一给返回值补一个包装变得自然,写一个 defer 就能覆盖所有返回路径。
注释写完那一段的可读性比之前好了一截。
因为我写过几十个这种函数之后,反过来更谨慎了,它绕过了 return 那行看上去很明确的赋值,读代码的人以为 7 就定了,实际最后出去的是 8。这种绕过去的赋值,是调试时最费时间的一种,断点打在对的位置也看不出问题,因为断点停下来的时候那个值是对的,继续走一步它才被换掉。我现在的规矩是只在同一个函数里同时改返回值且只改一次的时候才用,改两次以上的地方一律换普通写法,宁可多写几行,让返回值的走向写在纸面上。
这条纪律是被一次深夜排查逼出来的,一个接口的错误码对外一直是 500,函数里明明写了把 err 置空,翻到第三遍才看见底下还有个 defer 又把它填回去了。
那晚改完之后我把那段代码的 defer 全部提出来,逐个写了注释,说明它改的是哪个返回值,改几次,谁读谁写。
我现在的默认写法
改完重跑全套基准,第一组那三个数没有动。
综合下来我现在的习惯很简单,这个账我现在的算法是拿事故率去乘。函数里有需要成对释放的资源就写 defer,紧挨着获取的那一行写,中间不插任何东西。循环里不写 defer,要写就把循环体抽成函数。热路径上如果 defer 的数量在编译期定不下来,我会先量一次,量出来确实占了明显比例才去动它,而不是凭印象提前优化。
真正该盯的是分配次数那一栏,defer 让分配数从 3 涨到 9 的时候,问题不在 defer,在闭包。
五十纳秒乘一天一千万次调用,是半秒钟。一次漏写关闭导致文件句柄挂在线上,排查加修复通常是一下午。这里本来想算一笔更细的,但调用量的数据我没拿到,就先按这个量级说。所以热路径上的 defer 我一个都没拆,拆掉的都是本来就该拆的地方,循环体、defer recover、还有编译期数不清数量的那几种。
五种写法摆在一张表里
| 写法 | 每次开销 | 分配 | 什么时候该改 |
|---|---|---|---|
| 函数里一个 defer | 约 0.9 纳秒 | 0 | 不用改 |
| 函数里三个 defer | 约 2.6 纳秒 | 0 | 不用改 |
| 循环体里建闭包 defer | 间接带来多次分配 | 每次一个 | 抽成函数 |
| 数量在编译期定不下来 | 几十纳秒 | 一次 | 量过再动 |
| defer recover 放在热路径 | 同上 | 一次 | 能挪就挪 |
五个数都在上面那张表里。












