本文100%由本人(Haoxiang Ma)原创,如需转载请注明出处。
本文写于2019/02/16,基于
Go 1.11
。
至于其他版本的Go SDK,如有出入请自行查阅其他资料。
Overview
写本文的动机来源于Golang中文社区里一篇有头没尾的帖子《Go语言字符串高效拼接》,里面只提了Golang里面字符串拼接的几种方式,但是在最后却不讲每种方式的性能,也没有给出任何的best practice。本着无聊 + 好奇心,就决定自行写benchmark来测试,再对结果和源码进行分析,试图给出我认为的best practice吧。
性能测试
根据帖子里的内容,在Golang
里有5种字符串拼接的方式:
-
直接+号拼接
func (strs []string) string {
s := ""
for _, str := range strs {
s += str
}
return s
} -
fmt.Sprint()拼接
// fmt拼接
func ConcatWithFmt(strs []string) string {
s := fmt.Sprint(strs)
return s
} -
strings.Join()拼接
// strings.Join拼接
func ConcatWithJoin(strs []string) string {
s := strings.Join(strs, "")
return s
} -
Buffer拼接
// bytes.Buffer拼接
func ConcatWithBuffer(strs []string) string {
buf := bytes.Buffer{}
for _, str := range strs {
buf.WriteString(str)
}
return buf.String()
} -
Builder拼接
// strings.Builder拼接
func ConcatWithBuilder(strs []string) string {
builder := strings.Builder{}
for _, str := range strs {
builder.WriteString(str)
}
return builder.String()
}
为了测试各自的性能,就用Golang
自带test模块的benchmark来进行测试。
在测试中,分3组数据,5组测试,即一共3 * 5 = 15次独立测试。其中3组数据是指:
- size = 10K的字符串数组,每个元素均为
"hello"
- size = 50K的字符串数组,每个元素均为
"hello"
- size = 100K的字符串数组,每个元素均为
"hello"
5组测试是指:
- 直接+号拼接,要跑10K、50K、100K的数据
- fmt.Sprint()拼接,要跑10K、50K、100K的数据
- strings.Join()拼接,要跑10K、50K、100K的数据
- Buffer拼接,要跑10K、50K、100K的数据
- Builder拼接,要跑10K、50K、100K的数据
Benchmark代码如下:
package main import ( |
经过测试(go test -bench=. -benchmem
),结果如下:
...... |
可以看出
- 运行速度上,Builder、Buffer、Join的速度属于同一数量级,绝对值也差不了太多;fmt要比它们一个数量级;直接+号拼接是最慢的。
- 内存分配上,Join表现最优秀,Buffer次之,Builder第三;而fmt和直接+号拼接最差,要执行很多次内存分配操作。
源码分析
-
速度&内存分配都很优秀的
strings.Join()
func Join(a []string, sep string) string {
// 专门为短数组拼接做的优化
// 详情查阅golang.org/issue/6714
switch len(a) {
case 0:
return ""
case 1:
return a[0]
case 2:
return a[0] + sep + a[1]
case 3:
return a[0] + sep + a[1] + sep + a[2]
} // 计算总共要插入多长的分隔符,n = 分隔符总长
n := len(sep) * (len(a) - 1) // 遍历待拼接的数组,逐个叠加字符串的长度
// 最后n = 分隔符总长 + 所有字符串的总长 = 拼接结果的总长
for i := 0; i < len(a); i++ {
n += len(a[i])
} // 一次性分配n byte的内存空间,并且把第一个字符串拷贝到slice的头部
b := make([]byte, n)
bp := copy(b, a[0]) // 从下标为1开始,调用原生的copy函数
// 逐个把分隔符&字符串拷贝到slice里对应的位置
for _, s := range a[1:] {
bp += copy(b[bp:], sep)
bp += copy(b[bp:], s)
} // 最后将byte slice强转为string,返回
return string(b)
}可以看出
strings.Join()
为什么表现如此优秀,主要原因是只有1次的显式内存分配(b := make([]byte, n)
)和1次隐式内存分配(return string(b)
),不需要在拼接过程中反复多次分配内存,挪动内存里的数据,减少了很多内存管理的消耗。 -
略差一筹的
bytes.Buffer.WriteString()
// 尝试扩容n个单位
func (b *Buffer) tryGrowByReslice(n int) (int, bool) {
// 如果底层slice的剩余空间 >= n个单位,就不需要重新分配内存
// 而是reslice,把底层slice的cap限定在l + n
if l := len(b.buf); n <= cap(b.buf)-l {
b.buf = b.buf[:l+n]
return l, true
} // 如果底层slice的剩余空间不足n个单位,放弃reslice
// 说明需要重新分配内存,而不是reslice那么简单了
return 0, false
} // 扩容n个单位
func (b *Buffer) grow(n int) int {
m := b.Len() // 边界情况,空slice,先把一些属性reset掉
if m == 0 && b.off != 0 {
b.Reset()
} // 先试试不真正分配空间,通过reslice来“扩容”
if i, ok := b.tryGrowByReslice(n); ok {
return i
} // bootstrap是一个长度为64的slice,在buffer对象初始化时,
// bootstrap就已经分配好了,如果n小于bootstrap长度,
// 可以利用bootstrap slice来reslice,不需要重新分配内存空间
if b.buf == nil && n <= len(b.bootstrap) {
b.buf = b.bootstrap[:n]
return 0
} // 上述几种情况都无法满足
c := cap(b.buf)
if n <= c/2-m {
// 理解为m + n <= c/2比较好
// 如果扩容后的长度(m + n)比c/2要小,说明当前还有一大堆可用的空间
// 直接reslice,以b.off打头
copy(b.buf, b.buf[b.off:])
} else if c > maxInt-c-n {
// c + c + n > maxInt,申请扩容n个单位太多了,不可接受
panic(ErrTooLarge)
} else {
// 当前剩余的空间不太够了,重新分配内存,长度为c + c + n
buf := makeSlice(2*c + n)
copy(buf, b.buf[b.off:])
b.buf = buf
}
// Restore b.off and len(b.buf).
b.off = 0
b.buf = b.buf[:m+n]
return m
} // 拼接的方法
func (b *Buffer) WriteString(s string) (n int, err error) {
b.lastRead = opInvalid // 先尝试reslice得到len(s)个单位的空间
m, ok := b.tryGrowByReslice(len(s))
if !ok {
// 无法通过reslice得到空间,直接粗暴地申请grow
m = b.grow(len(s))
}
return copy(b.buf[m:], s), nil
}为什么
bytes.Buffer.WriteString()
性能比Join差呢,其实也是内存分配策略惹的祸。在Join里只有两次内存空间申请的操作,而Buffer
里可能会有很多次。具体来说就是buf := makeSlice(2*c + n)
这一句,每次重申请只申请2 * c + n
的空间,用完了就要再申请2 * c + n
。当拼接的数据项很多,每次申请的空间也就2 * c + n
,很快就用完了,又要再重新申请,所以造成了性能不是很高。 -
略差一筹的
strings.Builder()
func (b *Builder) WriteString(s string) (int, error) {
b.copyCheck()
b.buf = append(b.buf, s...)
return len(s), nil
}代码很简洁,就是最直白的slice append,一时append一时爽,一直append一直爽。所以当底层slice的可用空间不足,就会在append里一直申请新的内存空间。跟
bytes.Buffer
不同的是,这里并没有自己管理“扩容”的逻辑,而是交由原生的append函数去管理。 -
最差劲的
fmt.Sprint()
type buffer []byte type pp struct {
buf buffer
......
} func Sprint(a ...interface{}) string {
p := newPrinter()
p.doPrint(a)
s := string(p.buf)
p.free()
return s
}printer
里的核心数据结构就是buf
,而buf
其实就是一个[]byte
,所以给buf
不停地拼接字符串,空间不够了又继续开辟新的内存空间,所以性能低下。
总结
实际上,只有当拼接的字符串非常非常多的时候,才需要纠结性能。像本文里动辄拼接10K、50K、100K个字符串的情况在实际业务中应该是很少很少的。
如果实在要纠结性能,参考以下几点
- Join的速度最好,但是不至于完爆Builder和Buffer。三者的速度属于同一数量级。fmt和直接+号拼接速度最慢。
- Join的内存分配策略最好,内存分配次数最少;Builder和Buffer的内存分配策略还算可以,类似于线性增长;fmt和直接+号拼接的内存分配策略最差。