16 August 2018

IMG-THUMBNAIL

Go 1.10开始,引入了期盼已久的strings.Builder,Go 的作者是不是看到雨痕大大的优化文章搞的这个呢?

众所周知,Go 里面的字符串是常量,对字符串的修改会重新申请内存地址。为了优化这个,我之前都是用 bytes.Buffer 代替字符串的拼接等操作。这种方案避免了字符串修改过程中的内存申请,但是最后从[]byte转成字符串时会重新内存申请,这个无法避免。从 Go 1.10 开始,提供了更友好性能更好的方法 strings.Builder。

strings.Builder 和 bytes.Buffer 接口设计上基本一致

支持的方法是 bytes.Buffer 的子集,仔细看了一下,它实现了io.Writer接口,而 bytes.Buffer 实现了io.Readerio.Writer两个接口。

type Builder func (b *Builder) Grow(n int) func (b *Builder) Len() int func (b *Builder) Reset() func (b *Builder) String() string func (b *Builder) Write(p []byte) (int, error) func (b *Builder) WriteByte(c byte) error func (b *Builder) WriteRune(r rune) (int, error) func (b *Builder) WriteString(s string) (int, error)

type Writer interface {
        Write(p []byte) (n int, err error)
}

底层实现

type Builder struct {
	addr *Builder // of receiver, to detect copies by value
	buf  []byte
}

它底层还是用[]byte保存数据的,这和 bytes.Buffer 是一致的。

如果写入数据,就是在[]byte后面追加内容:

func (b *Builder) Write(p []byte) (int, error) {
	b.copyCheck()
	b.buf = append(b.buf, p...)
	return len(p), nil
}

追加内容也有讲究,因为底层是 slice,追加数据时有可能引起 slice 扩容。一般的优化方案是为 slice 初始化合理的空间,避免多次扩容复制。Builder 也提供了预分配内存的方法:

func (b *Builder) grow(n int) {
	buf := make([]byte, len(b.buf), 2*cap(b.buf)+n)
	copy(buf, b.buf)
	b.buf = buf
}

func (b *Builder) Grow(n int) {
	b.copyCheck()
	if n < 0 {
		panic("strings.Builder.Grow: negative count")
	}
	if cap(b.buf)-len(b.buf) < n {
		b.grow(n)
	}
}

注意扩容的容量和 slice 直接扩容两倍的方式略有不同,它是2*cap(b.buf)+n,之前容量的两倍加n。

  • 如果容量是10,长度是5,调用Grow(3)结果是什么?当前容量足够使用,没有任何操作;
  • 如果容量是10,长度是5,调用Grow(7)结果是什么?剩余空间是5,不满足7个扩容空间,底层需要扩容。扩容的时候按照之前容量的两倍再加n的新容量扩容,结果是2*10+7=27。

String() 方法有门道

func (b *Builder) String() string {
	return *(*string)(unsafe.Pointer(&b.buf))
}

返回当前数据的字符串,先获取[]byte地址,然后转成字符串指针,然后再取地址。

从 ptype 输出的结构来看,string 可看做 [2]uintptr,而 [ ]byte 则是 [3]uintptr,这便于我们编写代码,无需额外定义结构类型。如此,str2bytes 只需构建 [3]uintptr{ptr, len, len},而 bytes2str 更简单,直接转换指针类型,忽略掉 cap 即可。

详细可以参考雨痕的【Go性能优化技巧 1/10】

不允许复制

还是再看一下 Builder 的底层数据,它还有个字段addr,是一个指向 Builder 的指针。

type Builder struct {
	addr *Builder // of receiver, to detect copies by value
	buf  []byte
}

默认情况是它会指向自己:

b.addr = (*Builder)(noescape(unsafe.Pointer(b)))

而如果addr和当前指针所指地址不同,会引发panic异常。

func (b *Builder) copyCheck() {
	if b.addr == nil {
		// This hack works around a failing of Go's escape analysis
		// that was causing b to escape and be heap allocated.
		// See issue 23382.
		// TODO: once issue 7921 is fixed, this should be reverted to
		// just "b.addr = b".
		b.addr = (*Builder)(noescape(unsafe.Pointer(b)))
	} else if b.addr != b {
		panic("strings: illegal use of non-zero Builder copied by value")
	}
}

copyCheck用来保证复制后不允许修改的逻辑。仔细看下源码,如果addr是空,也就是没有数据的时候是可以被复制后修改的,一旦那边有数据了,就不能这么搞了。在GrowWriteWriteByteWriteStringWriteRune这五个函数里都有这个检查逻辑。

线程不安全

这个包并不是线程安全的,整个例子看看:

package main

import (
	"fmt"
	"strings"
	"sync"
	"sync/atomic"
)

func main() {
	var b strings.Builder
	var n int32
	var wait sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wait.Add(1)
		go func() {
			atomic.AddInt32(&n, 1)
			b.WriteString("1")
			wait.Done()
		}()
	}
	wait.Wait()
	fmt.Println(len(b.String()), n)
}

结果是902 1000,并不都是1000。如果想保证线程安全,需要在WriteString的时候加锁。

package main

import (
	"fmt"
	"strings"
	"sync"
	"sync/atomic"
)

func main() {
	var b strings.Builder
	var n int32
	var wait sync.WaitGroup
	var lock sync.Mutex
	for i := 0; i < 1000; i++ {
		wait.Add(1)

		go func() {
			atomic.AddInt32(&n, 1)

			lock.Lock()
			b.WriteString("1")
			lock.Unlock()
			wait.Done()
		}()
	}
	wait.Wait()

	fmt.Println(len(b.String()), n)
}

参考文献

原文链接:strings.Builder 源码分析,转载请注明来源!

EOF

长期招聘 Golang 程序员,可以给我发简历:lichao@cyeam.com。

本站总访问量次; 本站访客数人次; 本文总阅读量次;



相关推荐

blog comments powered by Disqus。如果你看不到评论框,加我微信或者自己想办法。