Go 高性能之对象复用

概述 #

sync.Pool 用来复用对象，减少内存分配，降低 GC 压力。

特性 #

sync.Pool 的大小可伸缩，高负载时会动态扩容，池中的对象在不活跃时会被自动清理。

如何使用 #

只需实现 sync.Pool 对象的 New 方法即可，当对象池中没有对象时，将会调用自定义的 New 方法创建。

package main

import (
	"sync"
)

type person struct {
	name string
	age  int
}

var (
	// 实现 New 方法
	personPool = sync.Pool{
		New: func() interface{} {
			return new(person)
		},
	}
)

func main() {
	// Get 方法从池中申请一个对象
	// 因为返回值是 interface{}, 这里再加一个类型转换
	tom := personPool.Get().(*person)

	tom.name = "Tom"
	tom.age = 6
	println(tom.name, tom.age)

	// Put 方法将对象归还到池中
	personPool.Put(tom)
}

普通方法 #

测试代码如下:

package performance

import (
	"bytes"
	"testing"
)

func BenchmarkBufferWithPool(b *testing.B) {
	data := make([]byte, 1024)

	for n := 0; n < b.N; n++ {
		// 每次初始化一个新对象
		var buf bytes.Buffer
		buf.Write(data)
		buf.Reset()
	}
}

运行测试，并将基准测试结果写入文件:

# 运行 1000 次，统计内存分配
$ go test -run='^$' -bench=. -count=1 -benchtime=1000x -benchmem > slow.txt

对象池 #

测试代码如下:

package performance

import (
	"bytes"
	"sync"
	"testing"
)

var bufferPool = sync.Pool{
	New: func() interface{} {
		return &bytes.Buffer{}
	},
}

func BenchmarkBufferWithPool(b *testing.B) {
	data := make([]byte, 1024)

	for n := 0; n < b.N; n++ {
		// 对象复用，从对象池中获取对象
		buf := bufferPool.Get().(*bytes.Buffer)
		buf.Write(data)
		buf.Reset()
		bufferPool.Put(buf)
	}
}

运行测试，并将基准测试结果写入文件:

# 运行 1000 次，统计内存分配
$ go test -run='^$' -bench=. -count=1 -benchtime=1000x -benchmem > fast.txt

使用 benchstat 比较差异 #

$ benchstat -alpha=100 fast.txt slow.txt 

# 输出如下:
name              old time/op    new time/op    delta
BufferWithPool-8    75.9ns ± 0%   500.0ns ± 0%    +558.94%  (p=1.000 n=1+1)

name              old alloc/op   new alloc/op   delta
BufferWithPool-8     2.00B ± 0%  1024.00B ± 0%  +51100.00%  (p=1.000 n=1+1)

name              old allocs/op  new allocs/op  delta
BufferWithPool-8      0.00           1.00 ± 0%       +Inf%  (p=1.000 n=1+1)