GoLang之strings.Builder底层

GoLang之strings.Builder底层

注：本文基于Windos系统上Go SDK v1.8进行讲解

1.strings.Builder结构体

1.1strings.Builder结构体

// A Builder is used to efficiently build a string using Write methods.
// It minimizes memory copying. The zero value is ready to use.
// Do not copy a non-zero Builder.
type Builder struct {
	addr *Builder // of receiver, to detect copies by value
	buf  []byte
}

1.2Write方法

// Write appends the contents of p to b's buffer.
// Write always returns len(p), nil.
func (b *Builder) Write(p []byte) (int, error) {
	b.copyCheck()
	b.buf = append(b.buf, p...)
	return len(p), nil
}

1.3WriteByte方法

// WriteByte appends the byte c to b's buffer.
// The returned error is always nil.
func (b *Builder) WriteByte(c byte) error {
	b.copyCheck()
	b.buf = append(b.buf, c)
	return nil
}

1.4WriteRune方法

// WriteRune appends the UTF-8 encoding of Unicode code point r to b's buffer.
// It returns the length of r and a nil error.
func (b *Builder) WriteRune(r rune) (int, error) {
	b.copyCheck()
	// Compare as uint32 to correctly handle negative runes.
	if uint32(r) < utf8.RuneSelf {
		b.buf = append(b.buf, byte(r))
		return 1, nil
	}
	l := len(b.buf)
	if cap(b.buf)-l < utf8.UTFMax {
		b.grow(utf8.UTFMax)
	}
	n := utf8.EncodeRune(b.buf[l:l+utf8.UTFMax], r)
	b.buf = b.buf[:l+n]
	return n, nil
}

1.5.WriteString方法

// WriteString appends the contents of s to b's buffer.
// It returns the length of s and a nil error.
func (b *Builder) WriteString(s string) (int, error) {
	b.copyCheck()
	b.buf = append(b.buf, s...)
	return len(s), nil
}

1.6String方法

和 bytes.Buffer 一样，strings.Builder 也支持使用 String() 来获取最终的字符串结果。为了节省内存分配，它通过使用指针技术将内部的 buffer bytes 转换为字符串。所以 String() 方法在转换的时候节省了时间和空间。

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

1.7Len方法

// Len returns the number of accumulated bytes; b.Len() == len(b.String()).
func (b *Builder) Len() int { return len(b.buf) }

1.8Cap方法

// Cap returns the capacity of the builder's underlying byte slice. It is the
// total space allocated for the string being built and includes any bytes
// already written.
func (b *Builder) Cap() int { return cap(b.buf) }

1.9Reset方法

// Reset resets the Builder to be empty.
func (b *Builder) Reset() {
	b.addr = nil
	b.buf = nil
}

1.10Grow方法

// Grow grows b's capacity, if necessary, to guarantee space for
// another n bytes. After Grow(n), at least n bytes can be written to b
// without another allocation. If n is negative, Grow panics.
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)
	}
}

1.11grow方法

// grow copies the buffer to a new, larger buffer so that there are at least n
// bytes of capacity beyond len(b.buf).
func (b *Builder) grow(n int) {
	buf := make([]byte, len(b.buf), 2*cap(b.buf)+n)
	copy(buf, b.buf)
	b.buf = buf
}

1.12copyCheck方法

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")
	}
}

2.strings.Builder介绍

与 bytes.Buffer 类似，strings.Builder 也支持 4 类方法将数据写入 builder 中。
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)
有了它们，用户可以根据输入数据的不同类型（byte 数组，byte， rune 或者 string），选择对应的写入方法。

3.存储原理

根据用法说明，我们通过调用 string.Builder 的写入方法来写入内容，然后通过调用 String() 方法来获取拼接的字符串。那么 string.Builder 是如何组织这些内容的呢？
通过 slice,string.Builder 通过使用一个内部的 slice 来存储数据片段。当开发者调用写入方法的时候，数据实际上是被追加（append）到了其内部的 slice 上。

4.拷贝问题

strings.Builder 不推荐被拷贝。当你试图拷贝 strings.Builder 并写入的时候，你的程序就会崩溃。
你已经知道，strings.Builder 内部通过 slice 来保存和管理内容。slice 内部则是通过一个指针指向实际保存内容的数组。
当我们拷贝了 builder 以后，同样也拷贝了其 slice 的指针。但是它仍然指向同一个旧的数组。当你对源 builder 或者拷贝后的 builder 写入的时候，问题就产生了。另一个 builder 指向的数组内容也被改变了。这就是为什么 strings.Builder 不允许拷贝的原因。

func main() {
	var b1 strings.Builder
	b1.WriteString("ABC")
	b2 := b1
	b2.WriteString("DEF")//出错在这一行，panic: strings: illegal use of non-zero Builder copied by value
}

func main() {
	var b1 strings.Builder
	b1.WriteString("ABC")
	b2 := b1
	fmt.Println(b2.String())//ABC
}

func main() {
	var b1 strings.Builder
	b1.WriteString("ABC")
	b2 := b1
	fmt.Println(b1.String()) //输出：ABC
	fmt.Println(b2.String()) //输出：ABC
	b1.WriteString("DEF")    
	fmt.Println(b1.String()) //输出：ABCDEF
	fmt.Println(b2.String()) //输出：ABC
}

但对于一个未写入任何东西的空内容 builder 则是个例外。我们可以拷贝空内容的 builder 而不报错。

func main() {
	var b1 strings.Builder
	b2 := b1
	fmt.Println(b1.String()) //输出空行
	fmt.Println(b2.String()) //输出空行
	b2.WriteString("DEF")
	fmt.Println(b1.String()) //输出空行
	fmt.Println(b2.String()) //输出：DEF
	b1.WriteString("ABC")
	fmt.Println(b1.String()) //输出：ABC
	fmt.Println(b2.String()) //输出：DEF
}

strings.Builder 会在以下方法中检测拷贝操作：
Grow(n int)
Write(p []byte)
WriteRune(r rune)
WriteString(s string)
所以，拷贝并使用下列这些方法是允许的：

func main() {
	// Reset()
	// Len()
	// String()
	var b1 strings.Builder
	b1.WriteString("ABC")
	b2 := b1
	fmt.Println(b2.Len())    // 3
	fmt.Println(b2.String()) // ABC
	b2.Reset()
	b2.WriteString("DEF")
	fmt.Println(b2.String()) // DEF
}

5.不能与nil作比较

6.Grow深入

strings.Builder 是通过其内部的 slice 来储存内容的。当你调用写入方法的时候，新的字节数据就被追加到 slice 上。如果达到了 slice 的容量（capacity）限制，一个新的 slice 就会被分配，然后老的 slice 上的内容会被拷贝到新的 slice 上。当 slice 长度很大时，这个操作就会很消耗资源甚至引起 内存问题。我们需要避免这一情况。
关于 slice，Go 语言提供了 make([]TypeOfSlice, length, capacity) 方法在初始化的时候预定义它的容量。这就避免了因达到最大容量而引起扩容。
strings.Builder 同样也提供了 Grow() 来支持预定义容量。当我们可以预定义我们需要使用的容量时，strings.Builder 就能避免扩容而创建新的 slice 了。
当调用 Grow() 时，我们必须定义要扩容的字节数（n）。 Grow() 方法保证了其内部的 slice 一定能够写入 n 个字节。只有当 slice 空余空间不足以写入 n 个字节时，扩容才有可能发生。举个例子：
builder 内部 slice 容量为 10。
builder 内部 slice 长度为 5。
当我们调用 Grow(3) => 扩容操作并不会发生。因为当前的空余空间为 5，足以提供 3 个字节的写入。
当我们调用 Grow(7) => 扩容操作发生。因为当前的空余空间为 5，已不足以提供 7 个字节的写入。
关于上面的情形，如果这时我们调用 Grow(7)，则扩容之后的实际容量是多少？
17 还是 12?
实际上，是 27。strings.Builder 的 Grow() 方法是通过 current_capacity * 2 + n （n 就是你想要扩充的容量）的方式来对内部的 slice 进行扩容的。所以说最后的容量是 10*2+7 = 27。
当你预定义 strings.Builder 容量的时候还要注意一点。调用 WriteRune() 和 WriteString() 时，rune 和 string 的字符可能不止 1 个字节。因为，你懂的，UTF-8 的原因。

func main() {
	var b1 strings.Builder
	fmt.Println(b1.Len()) //0
	fmt.Println(b1.Cap()) //0
	b1.Grow(3)
	fmt.Println(b1.Len()) //0
	fmt.Println(b1.Cap()) //3
	b1.Grow(1)
	fmt.Println(b1.Len()) //0
	fmt.Println(b1.Cap()) //3
}

func main() {
	a := strings.Builder{}
	a.Grow(11)
	fmt.Println(a.Len()) //0
	fmt.Println(a.Cap()) //11
	a.WriteRune('李')
	a.WriteRune('陆')
	a.WriteRune('豪')
	a.WriteRune('Z')
	a.WriteRune('Z')
	fmt.Println(a.Len()) //11
	fmt.Println(a.Cap()) //11	
}

7.不支持并行读写

和 bytes.Buffer 一样，strings.Builder 也不支持并行的读或者写。所以我们们要稍加注意。
可以试一下，通过同时给 strings.Builder 添加 1000 个字符：
通过运行，你会得到不同长度的结果。但它们都不到 1000。

func main() {
	var b strings.Builder
	n := 0
	var wait sync.WaitGroup
	for n < 1000 {
		wait.Add(1)
		go func() {
			b.WriteString("1")
			n++
			wait.Done()
		}()
	}
	wait.Wait()
	fmt.Println(len(b.String()))
	/*
			第一次运行输出：946
		   第二次运行输出：933
		 第三次运行输出：900
	*/
}