同样的字段,顺序一换就多占 8 字节

同样的字段,顺序一换就多占 8 字节
隔壁老康难度 ★★★☆☆ · 前置:方法、嵌入和 iota,结构体上最容易记混的三件事 | 一句话结论:字段按对齐值从大到小排,编译器就不用替你补空,两个字段一模一样、只有顺序不同的结构体,实测差了 8 字节。
1 | type A struct { |
我第一次认真去量结构体的大小,是因为一个缓存的占用涨得比我预期快。键和值是几个不大的结构体,字段加起来也就十来个字节,我按类型宽度估过(当时还在纸上列了一遍字段顺序,自认为算得很细),觉得再怎么样也占不了多少内存,于是把它当成一个可以忽略的常量放着,容量上限照着估出来的数一除就定了。后来顺手写了段程序把 unsafe.Sizeof 打出来,屏幕上那个数字比我估的多出一截,我盯着看了好一阵,先怀疑是自己把某个字段的类型记错了,又回头数了一遍字段,才想到该问一句,多出来的那些字节到底放在了哪儿。那几天我正好在算这个缓存的上限,算来算去对不上,问题就卡在这几个看不见的字节上。四个数各跑一遍,没取平均。在那之前我对结构体大小的理解只有一句话,字段有多宽,它就有多大。这句话单独看不算错,可它解释不了一件事,两个字段一模一样的东西,量出来为什么会不一样大。我当时把它归给对齐,对齐这两个字在文档里见过很多次,每次都是一句带过,好像看完就能懂,实际上我从来没有真的把某一次补位算出来过,也没有拿它改过任何一个类型。
中途还走过一次弯路,去翻了一篇讲对象头的文章,翻完才发现 Go 里根本没有那个东西,半个下午白花。
先看两个结构体,字段的类型、个数、名字全都一样,只有先后不同。
两个结构体,字段一模一样
A 依次是 bool、int64、bool,B 还是这三个类型,只是把最后那个 bool 提到了 int64 前面。代码贴在一起看,谁都觉得它们该一样大,一个 bool 一字节,一个 int64 八字节,加起来十个字节,多出来的部分当头部开销也说得过去。量出来 A 是 24 字节,B 是 16 字节,字段一个没多、一个没少、类型一个没换,差的这 8 字节跟数据类型没有关系,跟摆放顺序有关系,把三行字段挪个位置就完了,不需要重新设计类型,也不需要换数据结构,代价只有一次编译。
unsafe.Sizeof() 返回的是类型在内存里占的长度,含所有补位,也含末尾那个凑齐对齐的空当,不是字段宽度之和,拿字段宽度去估,天生就会估少。我第一次踩这个坑的时候还以为自己记错了 int64 的宽度,把 unsafe.Sizeof(int64(0)) 单独打了一遍,看到 8 才死心。
只换了顺序,差 8 字节。
对齐规则只有两句话
规则可以压成两句。每个字段的起始偏移,必须是它自身对齐值的整数倍。结构体的总大小,必须是它内部最大对齐值的整数倍。int64 的对齐值是 8,bool 是 1。A 的第一个字段占掉偏移 0,游标走到 1,第二个字段要从偏移 8 起才满足对齐,中间那 7 个字节就空着,第三个字段落在 16,占一字节,游标走到 17,最后整个结构体再向上取整到 8 的倍数,落回 24。B 的两个 bool 并排占掉 0 和 1,int64 从 8 开始,前面空 6 个,最后一个字段收在 16,正好是最大对齐值 8 的两倍,末位一格不差,也就没有第二段空当。我照着这两句话手算过,第一次漏掉了末尾那次向上取整,怎么算都差一截,补上才对上 24,纸上画的那张图比代码留得久,后来换了笔记本还夹在里面。空白也是成本。有人会说,一个结构体才几十字节,那点补位无所谓。这个判断放在单个对象上成立,放在一个装着成千上万个结构体的切片里就未必了,补位会跟着数量一起放大,而放大出来的是常驻内存,不是一次性的开销。
反过来也一样,省下来的补位不会立刻变成看得见的东西,它只是在你还什么都没做的时候就已经发生的浪费。
Go 的对齐规则和 C 基本一致,每个字段的起始偏移落在自身对齐值的整数倍上,结构体总大小再向上取整到最大对齐值。
这套约定的目的不是省内存,是让 CPU 一次就把字段读到手,不必为了跨边界多访一次内存,也正因为如此,补位不会被编译器悄悄省掉。
1 | A 偏移 0 8 16 24 |
那 8 个字节去哪了
把结构体按字节摆成格子最直观,一格一字节,有字段的写名字,补位的地方留白。
图里 A 的第 1 到第 7 格、第 17 到第 23 格都是空的,B 只在第 2 到第 7 格空着。同样三个字段,空的位置和数量都不一样,那 8 字节就藏在这些格子里,谁也没有多占,空出来的部分就是差值。
先看形状,再算数字。
编译器摆字段时手里只有一个游标,从 0 起步,每放一个字段,先把游标向上取整到该字段对齐值的倍数,再加上字段宽度,全部放完之后,再对整个结构体做一次同样的向上取整。整个过程里没有任何一步在权衡要不要省空间,它就是老实满足约束,空格是约束的副产品。
我拿纸推过这个流程,推完才发现以前靠感觉记下来的那些经验,其实都能从这一条推出来,包括为什么把一个 int32 从中间挪到最后能让结构体小一圈,也包括为什么嵌套一层之后原来的算法又得重算。
第一次用 unsafe.Offsetof 的时候我把字段名直接传进去,编译不过,翻了一下才知道要传 A{}.Count 这种带值的写法。
想自己复现的话就这一段,unsafe.Sizeof 对任何值都能用,打印出来的就是最终长度。
1 | fmt.Println(unsafe.Sizeof(A{}), unsafe.Sizeof(B{})) // 24 16 |
两个 Count 的偏移都是 8,区别在 Dirty 上,A 里它从 16 起,B 里它从 1 起,后面那截空当跟着就变了。偏移只说字段从哪儿开始,空到哪儿还得看下一个字段落在哪,最后一个字段后面那一截得靠总大小的取整补回来,三个数凑齐才是一张完整的图。
按对齐值倒着排,缝就没了
缝隙来自小字段挡在大字段前面,办法只有一条,把对齐值大的往前放,让小的去填缝:
| 排序 | 放什么 | 对齐值 |
|---|---|---|
| 1 | int64、float64、指针 |
8 |
| 2 | int32、rune |
4 |
| 3 | int16 |
2 |
| 4 | bool、byte |
1 |
这么排完,每个字段前面都正好对齐,缝只可能出现在末尾,末尾那点缝最多到最大对齐值减一,跑不出 7 个字节。这条经验在绝大多数结构体上都成立,不需要每次拿尺子量,只有嵌套和数组这两种情况要回头看一眼规则。顺序也是设计的一部分。做法可以很土:
- 先把字段列出来。
- 按宽度从大到小重排一遍。
- 把相关的字段凑在一起。
- 跑一次
unsafe.Sizeof对一下。
我要是不赶时间,一般会在类型上面留一行注释,写清楚为什么这么排,不然半年后有人往里加一个 int32,这个优化就悄悄没了,而且没人会注意到这件事发生过,直到有人拿 pprof 看到那个类型的热点里多出一块本不该有的内存占用,才会回头怀疑是不是有人动过字段顺序。我第一次照这个顺序排的是一个带十几个字段的配置类型,排完把前后的 unsafe.Sizeof 记在提交说明里,字节省了一点,可那个类型全进程只有一个实例,收益小得几乎看不见。后来学乖了,同一个类型在切片里成千上万份的时候才值得动手,单例的东西排得再整齐也只是心理安慰。例外出在嵌套上。结构体里嵌了别的结构体或者数组,对齐值按内部最大的那个算,一颗 int64 就能把外层顶到 8,这时候排序要看内部最大对齐值,不能只按字段自己的宽度,空结构体 struct{} 是另一种特例,它占 0 字节,放在最前面不影响任何偏移,常被拿来当集合的占位值。还有个更细的地方,结构体里混着数组和单个字段时,数组的对齐看元素类型,不看整个数组大小,[3]byte 的对齐是 1 而不是 3,它跟三个独立的 byte 在排版上是同一回事,只是位置上必须挨在一起,这一点在我第一次遇到 [3]int32 和三个 int32 排出来的大小一样时,才算真的记住,数组没有额外的头,它就是把元素一个接一个摊在那儿。
既然倒着排更省,编译器为什么不给排好?
从 8 字节的 map 到 8000 的数组
顺手把常打交道的类型量了一遍。int 是 8 字节,指针是 8 字节,string 是 16 字节,一个指向数据的指针加一个长度,[]byte 是 24 字节,比 string 多一个容量。
map 是 8 字节,chan 也是 8 字节,它们本身只指向运行时的结构,interface 是 16 字节,一个类型信息加一个数据指针,error 也是 16 字节,它本来就是个接口。这些数字里跟我直觉差得最远的是 map(我一直以为它内部有那么大一坨),量出来只有 8,真正的桶和数据都在别处,这个字段只是个把手,一个指向运行时结构的指针。
这也顺带解释了一件事,为什么把 []byte 传进函数并不复制底层数组,被复制的是那个 24 字节的头,数组还留在原地,string 同理,交出去的是头,不是身上那串字节。
接口是两个机器字。
struct{ A [1000]int } 量出来是 8000 字节,不是 8。数组不是指针,元素直接铺在结构体内部,一千个 int 就是八千字节,一个不少。
这一点让数组和切片在结构体里的地位完全不同。切片头 24 字节,里面装多少元素都不影响结构体大小,数组多大,结构体就多大,而且数组作为值会被整体复制,同一个类型换成切片之后,函数签名一个字没改,搬的东西少了一大半。
我刚开始写 Go 的时候在结构体里塞过固定长度的数组当缓存,觉得比切片少一次堆分配,测了一下才发现省的那点根本量不出来。
后来发现那个结构体每传一次就是一整块内存的复制,函数参数、方法接收者、channel 传递,每一处都在复制,省下来的那次分配,早就在别的地方还回去了,而且还得更贵,因为分配只发生一次,复制是每次调用都发生,调用次数一多,账就反过来了。
它是值,不是引用。判断方法也简单,字段写的是 [N]T 还是 []T,前者算进大小,后者只占一个头。后来我给自己加了条规矩,结构体里只放切片,真要放固定长度数组的地方,就在上面写一行注释说明为什么,省得下一次有人照着抄。
复制与比较都按字节算
结构体当 map 的键,每次查表都要算一次哈希,再在桶里逐个比较键,键越大,这两步碰的内存越多,同样的操作就更贵,这份开销还按查表次数付。
这不是理论推演,键类型的宽度直接决定了比较函数要跳过多少字节,拿一个大结构体当键,等于每次查表都把那一大块搬进比较逻辑里,在调用方的代码里看不出来。
每次调用都真的在复制。
在一个按内容去重的地方,我把一个带时间戳的结构体当键,同一个东西晚一秒进来就成了另一条,桶里散着一堆本该合并的记录,查了半天才反应过来是键里多带了字段。
结构体里有切片、map 或者函数就不能当键,编译器会直接报错,第一次撞上这条是在一个原本想按整个结构体去重的地方,最后拆出一个字段少得多的子结构当键,比较时要跳过的字节跟着就下来了。
值接收者的方法也在复制。
每调用一次就把整个类型复制一份进栈,结构体越大,成本越高,在循环里反复调用时这笔账跟着调用次数线性涨,这不是编译器不聪明,是值接收者这个语义本身的代价,方法要的就是一份碰不到外部的副本。
真要省掉这次复制,就把接收者换成指针,代价是多一次解引用和一层间接访问,换不换要看调用频率,一年调十次的地方不值得为此改设计。结构体越小,复制越便宜,把补位挤掉,省下的不只是内存,还有每一次复制。
缓存行是另一码事
还有一种跟结构体有关、但方向完全不同的现象,叫 false sharing。它说的不是单个结构体占多少字节,而是多个核同时改同一缓存行里的不同字段。CPU 的缓存以行为单位搬运,一行一般是 64 字节,两个字段哪怕只隔几个字节,只要落在同一行里,一个核改了其中一个,另一个核手里那一行就失效,得重新从内存拿。两个核看上去各改各的字段,实际上是在互相踩脚。这一段我只讲原理,没有测过,也不打算拿凑出来的数字充数,因为这类现象要证明它存在,得有两个核真的一起写,而我没有那个环境。我试过在自己机器上起两个 goroutine 各写一个 int64,跑出来的差别落在噪声里,来回几次都不稳,就没继续往下写。原理归原理,测过才算数。false sharing 的常见修法是给热点字段补空白,让它们落到不同的缓存行里,或者干脆把每个核要写的东西单独放一个结构体。
补位在 A 里面是浪费,到了这里反而成了手段,两个词看着像,用途不一样。
分清这两件事有个简单判断,字节数变多、访问变慢,那是补位,字节数没变、只有多核一起写才变慢,那是缓存行。
顺序是唯一由我决定的变量
回到开头那个缓存。差别不在类型上,在摆放顺序上,而顺序是可以随便改的,改完编译一次,量出来的数字就变了。改一行就能量出来。不需要任何运行时支持,也不需要重构,甚至不需要看懂编译器的源码,记住一条从大到小,剩下的量一次就清楚了。
结构体的大小从来不是字段宽度的和,它是编译器按对齐规则摆完之后的占用,补位也算在里面。
字段顺序是这份占用里唯一由我决定的部分,改起来不要钱,量起来也只要一行。













