点击上方蓝色“Go语言中文网”关注我们，领全套Go资料，每天学习 Go 语言

本文作者：鸟窝 smallnest，原文有视频讲解

原文链接：https://colobu.com/2019/12/31/small-changes-big-improvement/

Carlo Alberto Ferraris 提交了一个对math/rand库中的lockedSource优化的 pr(CL#191538^[1]),核心代码其实只有一行，却带来了相对的巨大的性能提升，让我们一起老看看这次的修改，学习一下代码的优化技巧，提高我们 Go 语言的底层优化经验。

实际测试中第三个保持在同一个cacheline优化并没有起作用，反而采用指针类型性能更好一点点。我实际测试发现也发现这个优化也没有特别明显的优化效果，所以下面的测试中并没有这个优化手段。

下面我们通过一个例子 ? 来比较采用这个方法前后的代码的性能，主要观察接口去掉后的性能提升和内联后的性能提升。

首先定义一个干果DryFruit的接口,它有一些通用的方法，比如名称、价格以及增加数量的方法(Increase), 因为只是做个演示，你不必深究这些方法的意义：

// DryFruit 干果接口.type DryFruit interface { Name() string Price() uint64    Family() string   Distribution() string Increase()}

下面我们定义一个栗子 ? 对象，它实现了干果接口：

// Chestnut 栗子.type Chestnut struct {  name  string  count uint64}

// Name 名称.func (c Chestnut) Name() string {return c.name}

// Price 价格.func (c Chestnut) Price() uint64 {return 10}

// Family Family name.func (c Chestnut) Family() string {return "Fagaceae"}

// Distribution 分布.func (c Chestnut) Distribution() string {return "East Asia"}

// Increase 数量加一func (c *Chestnut) Increase() {  c.count++}

接口和具体的实现都定义好了，我们需要定义一个使用它们的对象：礼物Gift。

未优化的礼物定义如下, 定义了一个OriginGift对象，它包含一个排外锁，还包含一个干果接口字段:

// OriginGift 未优化之前的礼物对象.type OriginGift struct {   mu       sync.Mutex   dryFruit DryFruit}

// Access 访问接口对象.func (g *OriginGift) Access() {    g.dryFruit.Name() g.dryFruit.Price()    g.dryFruit.Family()   g.dryFruit.Distribution() g.dryFruit.Increase()}

而我们的优化的 Gift struct 直接把接口对象替换成具体的栗子 struct:

// ImprovedGift 优化后的礼物对象.type ImprovedGift struct { mu       sync.Mutex   dryFruit *Chestnut}

// Access 访问具体的字段对象.func (g *ImprovedGift) Access() {  g.dryFruit.Name() g.dryFruit.Price()    g.dryFruit.Family()   g.dryFruit.Distribution() g.dryFruit.Increase()}

Benchmark 测试代码如下：

func BenchmarkOriginGift(b *testing.B) {var nut = &OriginGift{        dryFruit: &Chestnut{name: "栗子"},    }for i := 0; i < b.N; i++ {       nut.Access()  }}

func BenchmarkImprovedGift(b *testing.B) {var nut = &ImprovedGift{     dryFruit: &Chestnut{name: "栗子"},    }for i := 0; i < b.N; i++ {       nut.Access()  }}

func BenchmarkOriginGiftParallel(b *testing.B) {var nut = &OriginGift{     dryFruit: &Chestnut{name: "栗子"},    } b.RunParallel(func(pb *testing.PB) {for pb.Next() {         nut.mu.Lock()         nut.Access()          nut.mu.Unlock()       } })}

func BenchmarkImprovedGiftParallel(b *testing.B) {var nut = &ImprovedGift{        dryFruit: &Chestnut{name: "栗子"},    } b.RunParallel(func(pb *testing.PB) {for pb.Next() {         nut.mu.Lock()         nut.Access()          nut.mu.Unlock()       } })}

同时测试无并发的 benchmark, 然后测试并发访问时的性能。

第一次测试我们采用禁止内联的方式， 运行go test -gcflags "-N -l" -bench .:

goos: darwingoarch: amd64pkg: github.com/smallnest/study/perf_interfaceBenchmarkOriginGift-4                34669898            31.0 ns/opBenchmarkImprovedGift-4             58661895            17.9 ns/opBenchmarkOriginGiftParallel-4        7292043           171 ns/opBenchmarkImprovedGiftParallel-4        8718816           143 ns/op

可以看到将接口替换成具体的 struct 优化还是很明显的，非并发访问的情况下耗时几乎降到了一半，并发访问也有可观的性能提升。

第二次我们启用内联，看看和上面不启用内联的情况比较。

goarch: amd64pkg: github.com/smallnest/study/perf_interfaceBenchmarkOriginGift-4              95278143            12.6 ns/opBenchmarkImprovedGift-4             549471100            2.16 ns/opBenchmarkOriginGiftParallel-4      11631438           115 ns/opBenchmarkImprovedGiftParallel-4       13815229            86.3 ns/op

启用内联后，可以看到性能都有所提升，而去掉接口的方式性能优化更明显，直接降到了2.16 ns/op。

通过这两个 benchmark 的比较，你应该能深刻理解到这两种优化手段(去接口、内联)带来的巨大收益吧。

你可以通过 go test --gcflags "-m -m" -bench . 了解内联的具体细节。

参考资料

[1]

CL#191538: https://go-review.googlesource.com/c/go/+/191538/

推荐阅读

• xxx

喜欢本文的朋友，欢迎关注“Go语言中文网”：

Go语言中文网启用微信学习交流群，欢迎加微信：274768166