string 不可变这件事,值多少钱

string 不可变这件事,值多少钱
隔壁老康难度 ★★★☆☆ · 前置:Go 只有值传递,切片也一样 | 一句话结论:不可变让 string 能被安全地共享,代价是每次换类型都得真复制一份,1MB 一次五万纳秒上下,能省的只有少数不逃逸的场景。
我 2023 年 6 月开始写 Go,头半年对 string 的态度是能不管就不管,反正它就是一个文本。切片要关心 cap,map 要关心并发,channel 要关心关闭,string 看起来什么都不用操心,传进函数也不会被改坏。第一次觉得不对,是在一个给请求体做摘要的小服务里。每个请求进来都是一段 JSON,我在几个中间件之间传它,一会儿当 string 用,一会儿当 []byte 读,中间还顺手截过前几十个字节当日志前缀。那时候我以为开销在解析上,换过解析库,症状没变,后来把每个转换点都数了一遍,才发现同一份请求体在一条链路上被来回换了好几轮类型,每一轮都是整段复制。数完我给那条链路画了张图,四次转换里只有一次是真的需要字节,另外三次只是因为中间某个函数签名只认一种类型,而我又懒得把参数改成另一种。
那张图我在工位上贴了挺久,它比任何一篇讲字符串的文档都更早让我记住这件事的代价。它只是一份副本。
拆开看是三个问题,string 的头长什么样,转换成字节和拼起来各花多少钱,什么情况下可以不复制就把类型换过去。
三个答案都不长,串起来才有用。
十六个字节的头装不下容量
先看它的形状。
string 在内存里只有两个机器字,切片比它多一个:
| 类型 | 头里有几个字段 | 字节数 |
|---|---|---|
string |
一个指针、一个长度 | 16 |
[]byte |
一个指针、一个长度、一个容量 | 24 |
一个指针指向字节数组,一个长度记着有多少个字节,我在 64 位机器上用 unsafe.Sizeof 量过,空的 string 是 16。切片是 24,多出来的那个字段是 cap。这不是美学上的省略,容量对 string 根本没有意义,你不能往它后面 append,不能把它截短,也没有第二个所有者会跟它抢位置,既然长度不会变,容量就等于长度,多存一个数纯粹是浪费。
反过来说,正因为没有 cap,编译器才敢在任何地方把 string 当成一对只读的值来传递,复制这十六个字节就够了,底下的字节数组谁都不用动,谁也动不了。
这个差别看着只差一个字段,实际上把两个类型分成了两种用法,一种拿来读、拿来当标识,一种拿来攒、拿来改,选错的那一边,代价就是你每次都要换一份内存,而且换的时候还不一定想起来自己为什么要换。
头比内容便宜。复制头几乎不要钱,s2 := s1 就是复制十六个字节,两个 string 指向同一块字节数组,谁也不会改谁,因为谁也改不了。
这一点和切片很像,切片的头是二十四个字节,传参复制的也是头,不是底层数组。
区别在于切片之后可以 append,append 一旦碰到容量上限就要换一块新的底层数组,所以切片的指针是会变的,而 string 的头从创建那一刻就固定住了,指针和长度都不再改。
正因为头不变,编译器才敢在传参时只传这一对字,也才敢让同一个字符串常量在程序里被几十处共享同一份字节。
所以字符串的赋值和传参从来不是性能问题,问题永远出在那些看起来像赋值、实际上要另开一块内存的操作上(比如类型转换),比如拼接,比如把一个长串切成小串存进结构体。
1 | unsafe.Sizeof("") = 16 |
十六和二十四这两个数我反复用到,看一个函数的开销先看它返回什么,string 是十六字节的头,[]byte 是二十四字节的头,差别不在大小,在于后者带着一个可以被写、可以被扩容的身份。
一次转换五万一千纳秒
[]byte(s) 和 string(b) 在代码里出现得太自然,自然到人会以为它们是免费的语法糖。我把 1MB 的字符串和 1MB 的字节切片各跑了 2000 次,string 转 []byte 总计 105.67ms,反方向总计 104.66ms,两个方向上几乎没有区别。
这个结果第一次看有点反直觉,因为直觉上写操作更贵,可这里根本没有写,两次都是一次性分配一块 1MB 的内存,然后把 1MB 字节搬过去,方向和类型都不影响搬家的成本。go test -bench 的单次结果把这件事说得更直,分配量是 1048586 字节,比 1MB 多一点,allocs 那一栏是 1(也就是一次分配),多出来的那点字节被分配器拿去记账了。
这两个 bench 都只有一次分配,说明整个过程里没有第二块缓冲区,不存在先切一段再拼回去的情况,就是老老实实开一块新的,把字节抄过去。五万纳秒出头,换成好理解的说法是五十微秒上下,一次转换基本等于一次 1MB 的 memmove。
1 | BenchmarkStringToBytes 51425 ns/op 1048586 B/op 1 allocs/op |
换类型就是换一份内存。四个数各跑一遍,没取平均。
这个成本是线性的,2MB 就是两倍,1KB 就是千分之一,所以它不一定致命,但只要落在热路径上,它一定会出现在火焰图里。
我后来养成的习惯是先把转换次数数出来,再谈优化,因为五十微秒在单测里看不见,在一个每秒几万请求的入口上就是连续的分配和 GC 压力。
数的过程比想象中笨,就是把代码里所有的方括号和大括号对翻一遍,把每个 []byte(x) 和 string(y) 都标出来,标完往往能发现同一个值被换了两遍,中间还夹着一个根本不需要字节的函数。
这种地方通常不用什么高级手段,改一个函数签名,换一个参数类型,或者干脆让下游直接用 string,转换就消失了。
一千段拼下来差了一百倍
拼接是另一笔账,比转换更容易被忽略,因为 s += p 看起来只是一行赋值。我把 hello world 拼 1000 次,用 strings.Builder 是 7363 ns,直接加是 749930 ns,差了 102 倍。分配次数更刺眼,Builder 15 次,直接加 999 次,分配量是 46576 字节对 5829015 字节。原因不神秘,string 不可变,每次 s += p 都得新建一块能装下旧内容加新内容的数组,把旧的抄进去,把新的接在后面,旧的那块随即变成垃圾,拼一千次就是抄一千次前缀,总量是平方级的,n 越大越难看。这个增长曲线在数据量小的时候完全看不出来,拼十段、二十段,耗时就停在微秒级,等到某天输入从一千段变成五千段,它才突然显形,而那时你多半已经在看别的方向了。Builder 内部就是一块 []byte,append 进去,扩容走切片那一套按倍数长,所以一千次拼接只长大十几次。它的 String() 也不再复制,直接把那块 []byte 的头换个身份交出去。省下来的都是债。代价是那份零拷贝带了一条不能违反的约定,String() 交出去以后,Builder 就不能再写了,因为返回的 string 和内部的 []byte 是同一块内存,再写一次就是在改一个别人以为不会变的值。源码里为此放了一个 copyCheck 标记,一旦你把 Builder 按值复制、然后继续用其中一个写,它会直接 panic,而不是安静地给你一份错的数据。这个设计我很喜欢,能检查出来的错误不该留成隐患,代价是它把一个使用约束变成了运行时检查,你得先知道这条约束存在,才知道为什么传 Builder 要用指针。
同一件事换个写法差两个数量级,这在 Go 里不算罕见,语言把控制权交给你,也把记账的责任交给你,记账这件事没有编译器能替你做完,它只在你写错语法的时候提醒你。
1 | strings.Builder 7363 ns/op 46576 B/op 15 allocs/op |
子串借的内存不会自己松手
切片共享底层数组这件事,切片那篇里讲过了,string 的子串是同一个故事的另一半,而且更隐蔽。我从一个 10MB 的字符串上切出前 10 个字符,用 unsafe.StringData 比两个头的指针,返回 true,说明它们指向同一块内存。这意味着那个只装着十个字符的变量会一直吊住那 10MB,只要它活着,GC 就不会回收那 10MB,哪怕后面九点九九兆你再也用不到。因为切片头里那个指向底层数组的指针还在。
复制一份再比,结果变成 false,两个头指向不同的地址,这时候才真的只占十个字节,代价是搬了一次。这个坑在解析大报文时最容易踩,你从一整段响应里切出几个字段存进结构体,每切一个就多一个指针钉在那段响应上。请求量一上来,堆里全是被小字符串吊住的大块内存,看 heap profile 只看到一堆 10MB 的对象,看不出是谁拽着不放。要判断自己有没有踩,拿 unsafe.StringData 比一下指针,比翻文档快。要修也不难,strings.Clone 复制一份独立的字节,把和原串的关系切断,难的是知道在哪里切,切早了白搬一次,切晚了内存已经涨上去了。
共享是有代价的。一个只有二十个字节的子串,凭什么能钉住一兆的原文?
零拷贝的三个口子各有门槛
真想不复制,Go 留了三个口子,每个都带着条件:
| 口子 | 怎么写 | 前提是谁保证没人改 |
|---|---|---|
| 编译器优化 | m[string(b)] |
编译器自己看得出来 |
unsafe |
unsafe.String(&b[0], len(b)) |
你自己 |
| 容器 | Builder / bytes.Buffer |
约定加运行时检查 |
三个口子的共同点是不改变那块内存的归属,只是换了个视角去看它,谁在什么时机可以改它,才是真正的门槛,省下的那次复制不是白来的,是把这块内存归谁管这个问题从编译器手里接过来自己扛,扛不住的时候症状往往不是崩,是数据在某个你没预料到的时刻变了,变完还不报错。编译器优化的前提是它自己知道没人会改,unsafe 的前提是你自己知道,容器则是用约定和运行时检查把这件事管起来,三种保证的强度递减,责任递增,选哪一个取决于你能对那块内存负多大责任。门是开着的,钥匙自己配。
unsafe.String 最容易用错,因为它看起来只是换了个类型,实际上是把两个变量绑在同一块内存上。
b 只要在之后被写过一次,s 的内容就跟着变,而 string 的读者默认它不会变(这种默认一旦被打破),bug 会出现在离修改点很远的地方。
我的用法是把它限制在一个函数的几行之内,b 是局部变量,交给 s 之后就再也不碰,函数返回的只有 s,这样责任范围清楚,读代码的人也能看出来这块内存归谁。
1 | b := []byte("hello world") |
池子里捞出来的要先擦干净
高频的小对象适合用 sync.Pool 之类的容器复用 []byte,省下的是分配和 GC 的压力。代价是池子里捞出来的东西不一定是干净的,它的长度和内容都还是上一次用剩下的。所以取出来第一件事是按需要的长度截断,第二件事是确认要写的位置会被完整覆盖,否则读到的就是别人的残留。
这类问题的症状很像数据错乱,短消息后面跟着上一次长消息的尾巴,往缓冲区复用上想需要绕一圈,所以它比一般的 bug 更难查,也更容易被当成编码问题查半天,查到最后发现是池子记得上一轮的事,不是编码错了。池子还有个不太显眼的脾气,GC 的时候它会把池子里的东西清掉一部分,所以你不能指望放进去的东西下次一定还在。干净要自己保证。
要安全也简单,写之前按长度截断,需要清零就用 clear 或者重新赋值,别指望池子记得上次发生了什么。
这段里两次截断看着多余,其实必要,pool.Put 收的是长度为零的切片,下一次 Get 出来的人才能从干净的位置开始写。
1 | buf := pool.Get().([]byte) |
按字节切的刀落点不对
最后一个坑跟性能无关,跟语义有关。字符串的下标取到的是字节,s[0] 是第一个字节,不是第一个字符,按索引走的循环走的是字节位置。ASCII 内容里这两套坐标重合,所以大部分时候看不出问题,一旦内容里有中文或者其他多字节字符,按字节切就会切出半个字符。切出来的 string 仍然合法,Go 不管你的字节序列是不是合法的 UTF-8,它只是在打印和 range 的时候把非法字节显示成替换符,于是你会看到一串问号一样的东西,然后开始怀疑编码,怀疑终端,怀疑上游传错了,就是不怀疑自己切错了位置。要按字符切就用 range 或者 []rune,range 每次给你一个 rune 和它的起始字节位置,代价是它要逐字节解码,比按下标慢。字节和字符是两套坐标。
len(s) 返回的也不是字数,是字节数,一个中文字符在 UTF-8 里占三个字节,长度天生就对不上。
这个错我在给日志做截断时犯过,加了个按长度切的保护,结果切在字符中间,日志里天天出现半个汉字。
不可变买到的到底是什么
回到开头那个问题,string 的不可变值多少钱。它买到了共享的安全,十六字节的头可以在十几个变量之间自由复制,谁也不用担心谁改。它付出的代价是每次换类型都要真复制一份 1MB 的内存,五万一千纳秒,一次分配。
它还留下一些需要自己判断的缝隙,子串会吊住大内存,Builder 用过就不能再写,unsafe 的视角要自己守约定,这三笔加在一起就是不可变的定价,没有哪一条是白拿的。这些数字不会自动帮到你,但知道自己付了什么钱,改起来就有方向。下一次在热路径上写下 []byte(s) 的时候,你至少会停半秒。
![string 是 16 字节的头,[]byte 是 24 字节,差的就是 cap](https://img.kangai.me/cST7gg.webp)












