类型参数带来的是形状,不是运行时检查

类型参数带来的是形状,不是运行时检查
隔壁老康难度 ★★★★☆ · 前置:Go 服务上线前,我会过一遍的那张清单 | 一句话结论:类型参数在编译期就把函数体复制成具体的形状,运行时不查类型也不装箱,所以它跟手写那版一样快,代价是产物变大。
这个基准是我在给一个统计模块加求和函数的时候顺手写的。
那个包里原来只有一版针对 []int 的手写实现,我在旁边补了一个用类型参数加约束写的通用版本,又补了一个用 any 加类型断言的版本,三个函数干同一件事,只是签名长得不一样。跑基准之前我心里有个预期,觉得泛型那一版总要慢一点点,毕竟它多了一层抽象,而在别的语言里抽象大多是明码标价的。结果三行数字出来,泛型那行和手写那行的纳秒数挨得太近,近到我第一反应是自己把同一个函数重复跑了两遍,还专门回头翻了文件,确认这两行确实来自两段不同的实现。
先把三个数摆出来。
三个版本,三个数
三个函数都只做一件事,把一段整数加起来,返回同一个和。泛型那版的约束叫 Number,签名写着 T Number,any 版进来之后逐个做类型断言再相加,手写那版的参数就是 []int。三版摆在一起:
| 版本 | 参数类型 | 循环体里多做了什么 |
|---|---|---|
| 泛型 | []T,T Number |
什么都不用多,x 就是个整数 |
any |
[]any |
每次先 x.(int) 拆箱再相加 |
| 手写 | []int |
最直白,没有额外动作 |
1 | type Number interface { |
1 | BenchmarkGenericSum-32 17825305 63.94 ns/op 0 B/op 0 allocs/op |
泛型 63.94 纳秒,手写 63.71 纳秒,差 0.23 纳秒,比同一次运行里重复测同一个函数的抖动还小。any 那版 287.1 纳秒,是前两者的四倍半。抽象这次没收钱。两行一样的快。最左边是跑了多少次,中间是每次的平均耗时,右边两列是每次分配的字节数和分配次数。
六十三纳秒是编译器抄出来的
我原来以为泛型一定会慢,是因为把它和反射归成了一类东西。反射慢在哪儿我心里有数,它要在运行期拿着一个类型描述去问这是不是整数、字段在哪个偏移、这个值能不能取地址,每问一次都是一次函数调用加一串分支。泛型的写法跟反射有点像,都是先写一个带 T 的函数,等到调用的时候再把 T 换成具体的类型,所以我顺理成章地把两者放在了一起。后来才想明白,这两件事落在完全不同的阶段,反射把决定推迟到运行期,泛型把决定留在编译期,编译器生成代码的时候就已经知道 T 是 int,它替我把那个带 T 的函数体复制了一份出来,把里面的 T 全换掉了。
它只是一份抄出来的副本。所以运行时不查类型,也不装箱。
循环体里那个 x 的静态类型已经是 int,遍历拿到的就是一个个整数本身,加法编译成一条整数加法指令,没有接口,没有断言,没有额外的间接寻址。
换句话说,泛型的开销全部落在编译期和产物体积上,运行时那一栏是空的。
手写那一版在机器码层面做的事和它一样,循环、累加、返回,一条不多一条不少。
符号名里那个 go.shape.int_0
把编译产物拉出来看符号,泛型那一版在里面的名字带着形状,main.sum[go.shape.int_0],方括号里挂着这次实例化用的那个类型。手写那一版就是干净的 main.sumInt,没有任何后缀。go.shape 这个前缀的意思,是编译器先给这次实例化造了一个形状,再照着形状生成了一个独立的函数体。也就是说在我看不见的地方,源码里那一个 sum 变成了若干个函数,用 int 调用的时候生成一份,用 int64 调用的时候再生成一份,每一份都针对具体的宽度和指令集写死了,函数体和手写那一版长得几乎一样。它说明编译器把这个实例化当成一个独立的函数体来处理(而不是在原函数里塞一段分支),手写那一版和它在机器码层面几乎一样,指令顺序和循环形态都差不太多。方括号不是装饰,它是编译器区分这些副本的记号,同一份源码实例化两次,产物里就是两个名字不同的函数,它们互不相干,各自占着各自的代码段,谁也不会在跑起来之后回头去问对方是谁。
形状对了,代码就短了。这也解释了我最开始那个疑问,为什么两行基准数能差 0.23 纳秒。
差的那一点落在两次测量之间的正常抖动里,跟泛型的运行时开销没关系,换台机器、换一次运行,谁大谁小都可能翻过来。
两个数都落在 63 到 64 这个区间里,说它们一样快比说谁快一点更准确。
1 | main.sum[go.shape.int_0] |
装箱的四倍差价
any 那一版慢在一个很具体的地方。参数写的是 []any,调用方那几个整数得先各自包成一个接口值才能放进去,一个接口值占十六字节,里面两样东西,一样说明这值是什么类型,一样指着背后的数据。
包的过程要分配内存,实测那一行写着 48 字节、一次分配,正好是几个接口值摞起来的量。这个过程叫装箱,装箱我一行都没写,编译器在实参传进去之前替我插好了,源码上看不见,可它在每次调用的时候都实实在在跑了一遍。
进了函数之后还没完,每次加法之前都要拿 x.(int) 把值从接口里取出来,这个动作叫拆箱,运行时得先确认里面装的东西确实是个整数,再把它拷出来。
拆箱每次都要问一遍。其实把两个函数摊开看,循环长得几乎一样,都是 range 一遍、累加一遍,唯一的区别是 x 被拿进来的方式。泛型那版拿到的 x 就是一个 int,它在栈上,也可以待在寄存器里,取它不需要穿过任何一层。any 那版拿到的 x 是一个接口值,要相加先得把它拆开,拆开之后还得把里面的整数拷到临时位置,再参与运算。
这段差别写出来只有一行,落到几百万次循环上就是那一百多纳秒,多出来的那一次分配也长在这条路上。道理不复杂,泛型那版的循环体里只有几条整数运算指令,any 那版在同样的位置多出一段判断,先看类型字对不对,再从另一个地址把整数搬过来,就这么一段多出来的指令,摊到每一次迭代上。
那条断言不是白给的。那一次类型确认不是免费的,它要读接口值的类型字,和整数的类型描述比一下,对上了才继续。
一次两次看不出什么,几百万次乘下来就成了那一百多纳秒的差距。
(这两个数算过两次,第一次按四倍算的,除下来是 4.49,跟我嘴里说的四倍半差了半个身位。)287.1 除以 63.94 差不多是四点五,跟四倍多这个说法对得上。
多出来的那一次分配也在账上,泛型和手写两版都是零字节零次,任何一版进了热路径都不需要碰堆。
约束是编译期的一道门
Number 这个约束写成了 ~int | ~int64 | ~float64,它的作用只有一个,决定哪些类型能进来。传一个 string 进去,编译当场就停,给出来的原文是下面这样,写得很清楚,说 string 不满足 Number,因为它不在那三个底层类型里面。这种检查发生在编译期,编译器看一眼实参的类型,和约束里列的东西比一比,对不上就报错,一个字节的机器码都不会生成。反过来说,一旦类型对上了,约束在运行时就彻底消失了,产物里没有任何一行代码是留给它的,也没有谁会在跑起来之后回过头去问这一份到底满不满足那两个波浪号。
我一开始还担心约束会不会在每次调用的时候都查一遍,毕竟它写在签名上,看着像是函数的一部分,量完才把这个担心放下。
约束是编译期的事。
报错里那个 missing in 是关键词,它说的不是这个类型不够好,而是它压根不在这份清单上。
清单是约束里逐条列出来的类型集合,收敛得很死,多一个少一个都会当场被拦下来。
这句话可以推得更远一点,约束不产生任何运行时检查,它连一行代码都不生成。
它更像一张准入名单,贴在编译器的门口,名单之外的类型连门都进不来,名单之内的类型进来之后就不再被问第二遍。
1 | ./main.go:31:14: string does not satisfy Number (string missing in ~int | ~int64 | ~float64) |
一个波浪号隔开的那批类型
约束里最容易踩的一个坑是那个波浪号。~int 的意思是底层类型为 int 的所有类型,包含我自己定义的那些(比如 type MyInt int),它的底层类型就是 int,所以它满足 ~int。只写 int 就不要那个波浪号,意思立刻变窄,只认 int 这一个类型本身,MyInt 虽然长得一模一样,底层也是 int,照样进不来。
我拿后者试了一次,报错如下,说的是 MyInt 不满足 Number,因为 MyInt 不在 int 里面,措辞和上面那条一模一样,只是清单从一个集合缩成了一个具体类型。
这个坑我踩得挺实在,因为在别的地方 int 和 MyInt 基本可以混着用,赋值、运算、传参都行,只有到了约束这一栏才突然分家。
分家的理由也很正当,编译器要保证函数体里那些运算对每一个进来的类型都成立,自定义类型可能带着自己的方法,它宁可拦下来让我自己写清楚。差一个波浪号,差一批类型。有意思的是那个 any 版本,同一个 MyInt 不用改一行代码就能传进去,因为 any 没有约束,什么都能进。
代价也摆在那儿,前面那四倍多的差距就是从这儿来的,约束宽一分,编译器能替我做的事就少一分。
反过来说,约束写得越紧,编译器手里的信息越多,能生成的代码就越贴合。
松紧之间没有对错,只看这个函数要不要接住那些我还没想到的类型。
1 | ./main.go:28:14: MyInt does not satisfy Number (MyInt missing in int) |
什么时候不该写泛型
泛型不该用来省几行代码。我一开始就是奔着这个去的,觉得两个几乎一样的函数太啰嗦,合成一个带类型参数的版本多干净。真写下去才发现,省下的行数是十几行,代价是每个读这段代码的人都要先在脑子里把 T 换成具体类型,才能看懂它在干什么。一个函数只有一个调用点的时候,这个交换是亏的,调用点就那么一个,类型从头到尾没变过,泛型带来的复用一次都没用上,只留下了那层需要脑内替换的间接。我写 Go 写了两年多(这种为了整齐而多绕一层的改法踩过不止一次),最后基本都是改回去。
一个调用点不值得。
更合适的场合是容器类,是集合操作,是那些要被几十种类型反复调用的算法。这类东西的调用点天然多,类型参数带来的复用每用一次就回本一次,读代码的人也早就默认它是通用的,不需要额外的心理成本。
我自己划的线很土,同一个逻辑写到第三遍、而且这三遍的类型确实不同,才考虑抽成泛型。
写到第二版时会先复制一份,等第三次改动出现再回头合并,很多时候第三次根本不会来。
每个实例化都要占一份代码
泛型也有代价,只是这份代价不记在运行时的账本上。每一份实例化都是一份独立的函数体,都要占一段代码,用到的类型越多,产物就越大。我在一个包里拿五种类型调用过同一个函数,产物里就多出五份几乎一样的机器码。
类型少的时候这点体积不算什么,可要是一个被到处复用的工具函数碰上几十种类型,翻一翻二进制的大小就能看出来。实例化的类型太多时,编译时间也会明显变长,编译器得为每一种类型重新走一遍生成流程,原本一秒能完事的包会拖上好几秒。所以我现在写泛型的顺序是先问要不要,再问怎么写。
这个账在本地开发的时候几乎感觉不到,等到 CI 上排队构建几百个包,多出来的那几秒会乘出一个能看见的数字(尤其是那些到处都在用的通用工具函数),改一行就触发全量重编,整个流程都被它拖慢一截。
这就是那份形状的价钱。
真要写,约束从紧的那头开始试,能收多窄就收多窄,把波浪号用在该用的地方,别一上来就 any,那样等于把编译器能帮的忙全推掉了。
至于性能那一栏,这次量下来是不用担心的,泛型和手写几乎分不出高下,慢的是装箱那一版。
把类型参数用对地方,活儿在编译期就干完了,运行时不用多掏一分钱。实例化多了,二进制会大多少?












