channel 的缓冲不是越大越好,cap=0 反而最慢

难度 ★★★★☆ · 前置:一个 goroutine 只要 604 字节,但这不等于免费 | 一句话结论:无缓冲 channel 每传一个值都要一次 rendezvous,容量到 1024 就把收发两边的时间轴解开了,再往上加深几乎买不到吞吐。

我给自己派过一个把日志读出来再写回库的活,一头用 bufio 扫文件,一头用 database/sql 攒批插入,中间挂了一根 make(chan int, 0) 当管道,一百万行走完那一段空白比我想的久。我第一反应是数据库慢,第二反应是连接池太小,两条路都查到底才发现方向从一开始就歪了。后来我按阶段把墙上的时间拆开,看到读文件那一段和写库那一段几乎不重叠,两边在轮流醒着,谁都没闲着,谁也没跑快,那根通道像一道只容一个人过的门,两个 goroutine 一直在互相等对方点头,点完头才各自往前走半步。插桩的办法很土,每段前后各打一个 time.Now(),差值写进日志,跑完拿 awk 一减就是一张时间线,两段中间那道缝一画出来就摆在眼前。查连接池那半天现在想起来有点好笑,池子的等待时间一直是零,我盯着一根没人在那儿等的管道看了一下午。拆完我才明白,那段不重叠的时间不是谁懒,是两边根本没机会同时干活,读的人把值递出去才能去拿下一行,写的人接住才能去准备下一句 SQL。先量出形状再说。

于是我把同一份代码的缓冲容量依次换成 0、1、1024、65536,生产者的循环、消费者的累加、数据的类型全部不动,只让 make 的第二个参数变,容量是这份代码里唯一的自变量,别的都是常量。

先把四个容量各跑一遍

环境是 go1.27.2 的 windows/amd64,GOMAXPROCS=32,一个生产者一个消费者,一路传一百万个 int。

骨架抄在下面,消费者那一侧的循环体是空的,因为这里要量的是通道本身的成本,不是业务处理的成本。run 返回的是从第一次发送开始,到消费者退出的那段墙钟时间,返回之前不统计内存,也不做预热,每次都在同一个进程里新开两根 channel。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func run(capacity int) time.Duration {
ch := make(chan int, capacity)
done := make(chan struct{})
go func() {
for range ch {
}
close(done)
}()
start := time.Now()
for i := 0; i < 1_000_000; i++ {
ch <- i
}
close(ch)
<-done
return time.Since(start)
}

我只报比值,绝对值换台机器就变。

1
2
3
4
cap=0      195.1969ms
cap=1 148.0402ms
cap=1024 37.6174ms
cap=65536 33.3547ms

四个数字排在一起,形状很难看错。cap=0 到 cap=1 掉了一截,从 195.1969ms 落到 148.0402ms,说明哪怕只给出一个放东西的位置,发送方也不必每次都站到对面去等一个人。

四个数各跑一遍,没取平均。

cap=1 到 cap=1024 掉得最狠,148.0402ms 变成 37.6174ms,差不多是四倍。cap=1024 再往上加六十四倍容量,只换到 33.3547ms,快了一成出头。三个台阶一级比一级平,第一级砍掉的是等人,第二级砍掉的是排队,第三级几乎什么都没砍到。

每个容量我只跑一次,没取平均,要看的是台阶的高度差。

只看两头,195.1969 除以 37.6174 大约是 5.2,无缓冲比 cap=1024 慢了五倍还多。这个比值比任何一个单独的毫秒数都值得记,因为容量只从 0 挪到 1024,代码里多写一个数字,别的什么都没动,换回来的是五倍的时间。

这个实验我前后做过两轮,中间隔了一阵,机器状态不同,绝对值差出去很远,上一轮 cap=0 是 38.1844ms,cap=1 是 29.3784ms,cap=1024 是 6.4903ms,整条曲线比这一轮快了五倍左右。

我起初以为那次代码写得更干净,回头比对才发现逻辑一模一样,差别全在当时机器上还跑着别的东西。两轮放在一起看,形状在两次里一模一样,绝对值能差五倍。所以我下面反复说的都是形状,不是哪一格的毫秒数,照抄绝对数没有意义。

无缓冲那一次交接要把两个人叫醒

两个状态各改一次,这笔账最后算在谁头上?贵在两边都得改状态。

无缓冲的 channel 里没有地方存值,ch <- i 只有两条出路,而且哪条都不轻松。如果 recvq 里已经有人排着队等,发送方越过缓冲把值直接交到对方手里,再把它唤醒,运行时把这步收尾叫 rendezvous,交接的那一瞬间两个 goroutine 都停在同一个位置上,谁也走不了。如果对面还没人,发送方就把自己挂进 sendq,标成等待,让出当前的 P,等调度器以后把自己捡回来,捡回来之后还得重新确认一次对面是不是还在等。前一条路是一次约定,后一条路是一次上下文切换,共同点是两边都得改状态,没有哪条能省掉这一步。握手比排队贵。发送方从运行变成等待,接收方从等待变回可运行,中间还要穿过调度器的队列,一次交接至少两个 goroutine 各改一次状态,多出来的时间全花在商量上,跟传过去的值是八个字节还是一百字节关系不大。这一套动作在单次调用里看不见,一层层调用把成本摊薄了,可它乘上一百万次,就变成了几百毫秒的量级。我一开始也不信,觉得改个缓冲区大小怎么会牵动调度器,后来把发送那一行单独拎出来计时才看明白,无缓冲的发送根本不是一次内存写,它是一次协议,两个 goroutine 要先谈好谁先动,谈完才轮到数据。

那段时间我在 trace 上看这几个 goroutine 的状态迁移,两条线在同一个时刻交叉,交叉点上什么都没搬,光是两个状态各自改了一次。

两个状态各自改一次,这笔账到底算在谁头上?所以无缓冲 channel 慢的地方不在搬值,在搬值之前那一整套对齐。一百万次发送搬过去的 int 加起来不过八兆字节,这点数据在内存里挪一遍几乎不花时间,可它跑了一百九十多毫秒,绝大部分耗在互相等上。

有缓冲的时候这条路根本不用走,发送方看见数组里还有空位,写进去,qcount 加一,返回,商量这一步直接没了,剩下的只是一次下标运算和一次自增,前者跟元素大小无关,后者跟缓冲深度无关。

这两条路的差别不在成本高低的量级上,而在类型上,一条要走调度器,一条不用走,走一趟调度器的代价再怎么优化也压不回一次数组写入。

hchan 里那块环形数组

这些状态全装在一个运行时结构体里,名字叫 hchan,字段不多,和缓冲打交道的就那么几个。我第一次翻这段源码的时候当成一张表看,第二遍才看明白,真正让那块数组转起来的是两个游标。

1
2
3
4
5
6
7
8
9
type hchan struct {
qcount uint
dataqsiz uint
buf unsafe.Pointer
sendx uint
recvx uint
sendq waitq
recvq waitq
}

这八个字段干的活不一样,我读源码那两天在这张表上停了不少时间:

字段 管什么 我记它的办法
qcount 当前元素个数 和 dataqsiz 一减就是还剩几个空位
dataqsiz 缓冲大小 为零就是无缓冲,buf 根本不分配
buf 环形数组本体 长度正好是 dataqsiz
sendx 下次写哪儿 走到尾部绕回开头
recvx 下次读哪儿 同上,两个游标各绕各的
sendq 等着的发送方 sudog 双向链表,先来先走
recvq 等着的接收方 同上,抢同一根 channel 不插队

qcount 和 dataqsiz 两个一减就是还剩几个空位,发送方能不能直接写入,看的就是这一减的结果。buf 指向那块连续内存,长度正好是 dataqsiz。两个游标各自记着下一次往哪里写、从哪里读,走到尾部就绕回开头,这块数组因此看起来是个环。两条等待队列里挂的是 sudog 组成的链表,先来的先走,多个 goroutine 抢同一根 channel 不会插队。无缓冲和有缓冲用的是同一套字段,差别只在那块数组在不在,dataqsiz 为零的时候 buf 根本不分配,sendx 和 recvx 也就一直是零,两个游标闲着。游标绕回去,数据不搬家。环形的好处全在这一句里。数组如果不环,每读走一个元素就得把后面所有元素往前挪一格,一百万个元素挪下来是平方级的动作,游标一绕只改两个下标,代价是一次比较,跟元素多大、缓冲多深都没关系。这也是为什么容量从 1024 翻到 65536,读写本身的开销几乎没变,变的只是发送方撞上满数组的概率,以及挂着等人的那条链表的长度。所以曲线后面那段平坦,跟环形数组没关系,是等人的次数本来就少了,再往下压只能去压等人的成本,压数组是没有用的,数组那一段早就不是瓶颈了。

我刚开始读这段代码的时候一直以为游标会带着数据一起走,后来才明白它挪的只有下标。

hchan 的字段:环形数组与两个等待队列

缓冲满的那天还是会堵住

缓冲再大也绕不过一个根本问题,如果生产速度持续高于消费速度,数组迟早被填满,满了之后发送方照旧挂进 sendq,照旧要等一次接收方腾出手来,这时候它跟一根无缓冲 channel 上的发送方没有本质区别,区别只在于它已经白等了一段填满的时间。缓冲能买到的东西是把生产和消费在时间上解开,生产者一阵猛冲,消费者慢慢跟,中间那段差额先存在数组里,等生产者喘气的时候消费者再把欠的补上,补的时候还是要一个一个搬出去,攒着并不会让搬运本身变便宜,只是把搬运的时间挪后了。满了照旧要等。这段解耦能吸收多长的抖动,取决于容量除以速度差得到的那个商,速度差为零的时候再小的容量都够用,速度差为正的时候多深的容量也只是晚一点到满。拿这个商回头看前面那四个数就对上了,cap=0 的时候两边完全没有时间上的余量,每传一个值都必须当场对上,所以它最慢。cap=1024 给了一千个值的余量,两边各有自己的节奏,速度差被这段余量吸收掉,时间自然掉下来。这个商我算不出来,因为生产速度和消费速度都在变,但它的方向很清楚,容量是分子,速度差是分母,分母趋近零的时候分子多大都没意义。

缓冲不是消除,是摊平。所以容量该按最坏情况下的速度差来估,而不是按平均速度来估。

平均速度只会让你觉得几十的容量就够了,最坏情况一到来,前面省下的那点内存全被几次阻塞还回去。

一千之后加的容量在买什么

容量加到 65536,只比 1024 快一成。

cap=1024 到 cap=65536 之间差了六十四倍容量,换回来的只有不到百分之十二。这也是为什么一千之后再加深看不到收益,跨过这道坎以后,再加深度基本是给自己买心理安慰。

曲线的形状在对数坐标上先陡后平,前面那一段是把等人的时间换成放值的时间,后面那一段只是把数组撑大,撑大本身不花时间,可它花内存,而这片内存一直挂在那根 channel 上,直到通道被回收才还回去。

期间别的 goroutine 想用也用不上,调度器也不会因为这块内存闲着就把它借给别人。我算过,把这根通道的容量从 1024 调到 65536,相当于给一个只会用掉个位数空位的场景,预先备下六万多个可能永远填不满的格子。

65536 个 int 是五百一十二 KB,每一根这样的 channel 都要实打实占这么多,一个服务里开几十根管道,几十兆内存就出去了,换回来的吞吐还在噪声范围里晃,我量不出一条稳定的好处来。

四种缓冲容量的耗时对比

容量翻六十四倍,收益只剩一成。

真要在这一档再往上提速,方向不在容量上。换成批量的值、把两边合并进一个 goroutine、或者换一种同步原语,都比继续加深缓冲有意义,因为加深解决的是等待,而一千之后等待已经不是主要成本。

我后来在一根吞吐上不去的管道上试过把每次发送的值换成一个小结构体,问题立刻从容量跑到了别的地方,那时候才彻底放弃继续加深度这条路。

传值还是传指针看结构体多胖

它交出去的只是副本。

channel 的 buf 是一个值的数组,写进去必然复制一次,传 int 是八个字节的复制,传一个几百字节的结构体就是几百字节的复制,而且这次复制发生在持有 hchan 锁的临界区里。慢的还不只是 memcpy 本身,锁被占着的时间变长了,别的生产者排队等着拿锁的那段也跟着变长,一批 goroutine 挤在同一根 channel 上,复制成本会被放大成排队成本,本来只是一次内存搬运,最后变成一串人干等着。锁的争用和复制的体量绑在一起,结构体越胖,这两笔成本一起涨,而且是相乘的关系。

判断胖瘦我自己用的线是缓存行,一个结构体超过六十四字节,一次复制就要跨过整条缓存行,再往上复制就成了主要开销,这时候传指针更划算,接收方自己去读那块内存,代价是要保证没人同时在改它。小于这条线的时候传值更省事,不用担心谁改坏了谁,也不用担心那块内存被谁提前回收。

close 之后只剩三种反应

三种反应里哪一种最容易写错?close 只该由发送方调用(这条规矩背后是三条硬行为),每一条都由运行时直接决定,没有商量的余地。

对着一根已经关闭的 channel 会发生什么 谁能做
发送 当场 panic,没有任何补救的机会 只有发送方
接收 不阻塞,立刻拿到零值和 false 接收方,只能观察
range 遍历 循环自己结束,不用额外判断 接收方,只能观察

三个 false 背后是同一件事,那个布尔值就是通道已经关了的信号。

三条合起来的意思很明确,关闭是发送方的动作,接收方只能观察,不能参与,所以这个动作才不能由接收方发起。反过来想也成立,接收方唯一能做的是在拿到 false 之后不再读,别的什么都做不了。关的人只能是发的人。所以有多个发送方的时候谁都不该随手 close,因为没法知道别人发完没有,这种场合通常另开一根 done channel,让该退出的地方去监听它。还有一条容易忘的,nil channel 上的收发都会永久阻塞,只有 select 里的 nil case 会被跳过。这个特性常被拿来做动态开关,把某个 case 的 channel 置成 nil,那个分支就哑了。

我现在的默认值和它的来路

现在我写生产消费管道,容量默认给 1024 左右,理由就是前面那条线,0 到 1024 是整条曲线上最陡的一段,把这段走完,剩下的空间再深也只是浪费内存。

真正需要压延迟、两边必须严格同步的地方才用无缓冲,那种地方要的不是吞吐,是每传一个值双方都确认一次(比如一个 goroutine 把任务交出去),要等到对面真的接住了才继续往下走。参数是量出来的。