Golang 反射性能优化

文章来源：infoq余歌

Golang的反射最为人诟病的就是它极差的性能，接下来我们尝试优化它的性能。

如果我们使用正常的流程来创建一个对象，将会是如下的代码片段：


type People struct {
    Age   int
    Name  string
}

func New() *People {
    return &People{
        Age:   18,
        Name:  "shiina",
    }
}

以上的代码非常好读，但是如果我们要开发一款框架，接收的类型非常有可能是动态的、不确定的，那么就会使用到反射(Reflect)功能，使用反射来创建一个如上的Person对象大概是如下的代码片段：


func NewUseReflect() interface{} {
    var p People
    t := reflect.TypeOf(p)
    v := reflect.New(t)
    v.Elem().Field(0).Set(reflect.ValueOf(18))
    v.Elem().Field(1).Set(reflect.ValueOf("shiina"))
    return v.Interface()
}

如上是一段普通的反射代码，既然大家都说Go的反射性能极差，那么我们就来自己看一下它的性能和上一个我们正常创建Person对象比性能差了多少。

简单的性能测试

让我们先用Go自带的go bench来分析一下它的性能


func BenchmarkNew(b *testing.B) {
    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        New()
    }
}

func BenchmarkNewUseReflect(b *testing.B) {
    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        NewUseReflect()
    }
}

我们得到的测试结果如下：


BenchmarkNew
BenchmarkNew-16                 1000000000           1.55 ns/op        0 B/op          0 allocs/op
BenchmarkNewUseReflect
BenchmarkNewUseReflect-16        4787185           248 ns/op          64 B/op          2 allocs/op

我们能够发现使用反射的耗时是不使用的160倍左右

性能损耗的猜测

那么反射创建对象，主要的性能损耗在哪里呢？我们先进行一个实验：

并且当我们增加更多的结构体成员变量，比如增加两个string类型的成员变量，进行一次性能测试，然后再去掉所有的成员变量，进行一次性能测试。

四个成员变量：


type People struct {
    Age   int
    Name  string
    Test1 string
    Test2 string
}

func New() interface{} {
    return &People{
        Age:  18,
        Name: "shiina",
    Test1: "test1",
    Test2: "test2",
    }
}

func NewUseReflect() interface{} {
    var p People
    t := reflect.TypeOf(p)
    v := reflect.New(t)
    v.Elem().Field(0).Set(reflect.ValueOf(18))
    v.Elem().Field(1).Set(reflect.ValueOf("shiina"))
    v.Elem().Field(2).Set(reflect.ValueOf("test1"))
    v.Elem().Field(3).Set(reflect.ValueOf("test2"))
    return v.Interface()
}

——————————————————————————————————————————
BenchmarkNew
BenchmarkNew-16                 1000000000           1.12 ns/op        0 B/op          0 allocs/op
BenchmarkNewUseReflect
BenchmarkNewUseReflect-16        3334735           366 ns/op         128 B/op          2 allocs/op

无成员变量：


type People struct{}

func New() interface{} {
    return &People{}
}

func NewUseReflect() interface{} {
    var p People
    t := reflect.TypeOf(p)
    v := reflect.New(t)
    return v.Interface()
}

——————————————————————————————————————————
BenchmarkNew
BenchmarkNew-16                 1000000000           1.32 ns/op        0 B/op          0 allocs/op
BenchmarkNewUseReflect
BenchmarkNewUseReflect-16       17362648            62.3 ns/op         0 B/op          0 allocs/op

我们猜测，反射性能的损耗具体分为两个部分，一个部分是reflect.New()，另一个部分是value.Field().Set()

这时候我们可以使用Go原生自带的性能分析工具pprof来分析一下它们的主要耗时，来验证我们的猜测。

我们对四个成员变量测试用例使用pprof：


# 生成测试数据
kieranhu@KIERANHU-MC0 ~/Downloads> go test -bench=. -benchmem -memprofile memprofile.out -cpuprofile profile.out
# 分析测试数据
kieranhu@KIERANHU-MC0 ~/Downloads> go tool pprof ./profile.out
Type: cpu
Time: Apr 24, 2020 at 7:38pm (CST)
Duration: 2.02s, Total samples = 1.92s (94.91%)
Entering interactive mode (type "help" for commands, "o" for options)
(pprof) list NewUseReflect

我们使用pprof得到了该函数的主要耗时，可以发现与我们的猜测无误，耗时主要分为三个部分：reflect.TypeOf(),reflect.New(),value.Field().Set(),其中我们可以把reflect.TypeOf()放到函数外，在初始化的时候生成，接下来我们主要关注value.Fidle().Set()


ROUTINE ======================== begonia.NewUseReflect in /Users/kieranhu/go/src/begonia/reflect_test.go
      60ms      2.17s (flat, cum) 64.97% of Total
         .          .     29:
      10ms       10ms     30:func NewUseReflect() interface{} {
         .          .     31:   var p People
      10ms      580ms     32:   t := reflect.TypeOf(p)
         .      440ms     33:   v := reflect.New(t)
      10ms      220ms     34:   v.Elem().Field(0).Set(reflect.ValueOf(18))
      10ms      250ms     35:   v.Elem().Field(1).Set(reflect.ValueOf("shiina"))
         .      280ms     36:   v.Elem().Field(2).Set(reflect.ValueOf("test1"))
      10ms      220ms     37:   v.Elem().Field(3).Set(reflect.ValueOf("test2"))
      10ms      170ms     38:   return v.Interface()
         .          .     39:}
         .          .     40:

干掉 value.Field().Set()

我们先从怎么不用xxx=xxx进行赋值说起。

unsafe

Go中有一个包叫unsafe,顾名思义，它不安全，因为它可以直接操作内存。我们可以使用unsafe，来对一个字符串进行赋值，具体的步骤大概如下：

获得该字符串的地址
对该地址赋值

我们通过四行就可以完成上面的操作：


    str := ""
    // 获得该字符串的地址
    p := uintptr(unsafe.Pointer(&str))
    // 在该地址上赋值
    *(*string)(unsafe.Pointer(p))="test"
    fmt.Println(str)
-----------------
test

当我们能够使用unsafe来操作内存时，就可以进一步尝试操作结构体了。

操作结构体

我们通过上述代码，得到一个结论：

只要我们知道内存地址，就可以操作任意变量。

接下来我们可以尝试去操作结构体了。

Go的结构体有以下的两个特点：

结构体的成员变量是顺序存储的
结构体第一个成员变量的地址就是该结构体的地址。

根据以上两点，以及刚刚我们得到的结论，我们可能够得到以下的方法，来干掉value.Field().Set()

获得结构体地址
获得结构体内成员变量的偏移量
得到结构体成员变量地址
修改变量值

我们逐个来获得获得。

Go中interface类型是以这样的形式保存的：


// emptyInterface is the header for an interface{} value.
type emptyInterface struct {
    typ  *rtype
    word unsafe.Pointer
}

这个结构体的定义可以在reflect/Value.go找到。

在这个结构体中typ是该interface的具体类型，word指针保存了指向结构体的地址。

现在我们了解了interface的存储类型后，我们只需要将一个空接口interface{}转换为emptyInterface类型，然后得到其中的word，就可以拿到结构体的地址了，即解决了第一步。

结构体类型强转

先用下面这段代码示例，来解决一下不同结构体之间的转换：


type Test1 struct {
    Test1 string
}

type Test2 struct {
    test2 string
}

func TestStruct(t *testing.T) {
    t1 := Test1{
        Test1: "hello",
    }

    t2 := *(*Test2)(unsafe.Pointer(&t1))
    fmt.Println(t2)
}
----------------
{hello}

然后我们更换两个结构体中的成员变量类型，再尝试一下：


type Test1 struct {
    a int32
    b []byte
}

type Test2 struct {
    b int16
    a string
}

func TestStruct(t *testing.T) {
    t1 := Test1{
        a:1,
        b:[]byte("asdasd"),
    }

    t2 := *(*Test2)(unsafe.Pointer(&t1))
    fmt.Println(t2)
}
----------------
{1 asdasd}

我们可以发现，后面这次尝试两个结构体的类型完全不同，但是其中int32和int16的存储方式相同，[]byte和string的存储方式相同，我们可以得出一个简单的结论：

不论类型签名是否相同，只要底层存储方式相同，我们就可以强制转换，并且可以突破私有成员变量限制。

通过上面我们得到的结论，可以将reflect/value.go里面的emptyInterface类型复制出来。然后我们对interface强转并取到word，就可以拿到结构体的地址了。


type emptyInterface struct {
    typ  *struct{}
    word unsafe.Pointer
}

func TestStruct(t *testing.T) {
    var in interface{}
    in = People{
        Age:   18,
        Name:  "shiina",
        Test1: "test1",
        Test2: "test2",
    }

    t2 := uintptr(((*emptyInterface)(unsafe.Pointer(&in))).word)
    *(*int)(unsafe.Pointer(t2))=111
    fmt.Println(in)
}
---------------
{111 shiina test1 test2}

我们获取了结构体地址后，根据结构体地址，修改了结构体内第一个成员变量的值，接下来我们开始进行第二步：得到结构体成员变量的偏移量

我们可以通过反射，来轻松的获得每一个成员变量的偏移量，进而根据结构体的地址，获得每一个成员变量的地址。

当我们获得了每一个成员变量的地址后，就可以很轻易的修改它了。


var in interface{}
    in = People{
        Age:   18,
        Name:  "shiina",
        Test1: "test1",
        Test2: "test2",
    }

    typeP := reflect.TypeOf(in)
    offset1 := typeP.Field(1).Offset
    offset2 := typeP.Field(2).Offset
    offset3 := typeP.Field(3).Offset

    t2 := uintptr(((*emptyInterface)(unsafe.Pointer(&in))).word)

    *(*int)(unsafe.Pointer(t2)) = 111
    *(*string)(unsafe.Pointer(t2 + offset1)) = "hello"
    *(*string)(unsafe.Pointer(t2 + offset2)) = "hello1"
    *(*string)(unsafe.Pointer(t2 + offset3)) = "hello2"
    fmt.Println(in)
---------------------
{111 hello hello1 hello2}

我们刚刚成功的利用地址修改了结构体的成员变量，没有使用到value.Field().Set()。接下来我们利用刚刚的技巧，修改反射函数，并再次进行性能测试。

我们保留以前的反射函数做对比，新建一个NewQuickReflect()来使用这种技巧创建对象：


var (
    offset1 uintptr
    offset2 uintptr
    offset3 uintptr
    p       People
    t       = reflect.TypeOf(p)
)

func init() {
    offset1 = t.Field(1).Offset
    offset2 = t.Field(2).Offset
    offset3 = t.Field(3).Offset
}

type People struct {
    Age   int
    Name  string
    Test1 string
    Test2 string
}

type emptyInterface struct {
    typ  *struct{}
    word unsafe.Pointer
}

func New() *People {
    return &People{
        Age:  18,
        Name: "shiina",
    Test1: "test1",
        Test2: "test2",
    }
}

func NewUseReflect() interface{} {
    v := reflect.New(t)

    v.Elem().Field(0).Set(reflect.ValueOf(18))
    v.Elem().Field(1).Set(reflect.ValueOf("shiina"))
    v.Elem().Field(2).Set(reflect.ValueOf("test1"))
    v.Elem().Field(3).Set(reflect.ValueOf("test2"))
    return v.Interface()
}

func NewQuickReflect() interface{} {
    v := reflect.New(t)

    p := v.Interface()
    ptr0 := uintptr((*emptyInterface)(unsafe.Pointer(&p)).word)
    ptr1 := ptr0 + offset1
    ptr2 := ptr0 + offset2
    ptr3 := ptr0 + offset3
    *((*int)(unsafe.Pointer(ptr0))) = 18
    *((*string)(unsafe.Pointer(ptr1))) = "shiina"
    *((*string)(unsafe.Pointer(ptr2))) = "test1"
    *((*string)(unsafe.Pointer(ptr3))) = "test2"
    return p
}

func BenchmarkNew(b *testing.B) {
    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        New()
    }
}

func BenchmarkNewUseReflect(b *testing.B) {
    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        NewUseReflect()
    }
}

func BenchmarkNewQuickReflect(b *testing.B) {
    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        NewQuickReflect()
    }
}

运行后我们的测试结果：


BenchmarkNew
BenchmarkNew-16                 1000000000           1.34 ns/op        0 B/op          0 allocs/op
BenchmarkNewUseReflect
BenchmarkNewUseReflect-16        3715539           276 ns/op          64 B/op          1 allocs/op
BenchmarkNewQuickReflect
BenchmarkNewQuickReflect-16     12772573            94.7 ns/op        64 B/op          1 allocs/op

可以看出我们的性能从原生205倍提升到了70倍，并且这个优化的程度将会随着结构体成员变量越多而越明显。

我们对新写的NewQuickReflect函数使用pprof分析一下，继续观察有没有可以优化的点。


ROUTINE ======================== begonia.NewQuickReflect in /Users/kieranhu/go/src/begonia/reflect_test.go
     120ms      1.07s (flat, cum) 28.53% of Total
         .          .     57:
         .          .     58:func NewQuickReflect() interface{} {
      40ms      800ms     59:   v := reflect.New(t)
         .          .     60:
         .      180ms     61:   p := v.Interface()
         .          .     62:   ptr0 := uintptr((*emptyInterface)(unsafe.Pointer(&p)).word)
      40ms       40ms     63:   ptr1 := ptr0 + offset1
      10ms       10ms     64:   ptr2 := ptr0 + offset2
         .          .     65:   ptr3 := ptr0 + offset3
      10ms       10ms     66:   *((*int)(unsafe.Pointer(ptr0))) = 18
         .       10ms     67:   *((*string)(unsafe.Pointer(ptr1))) = "shiina"
         .          .     68:   *((*string)(unsafe.Pointer(ptr2))) = "test1"
         .          .     69:   *((*string)(unsafe.Pointer(ptr3))) = "test2"
      20ms       20ms     70:   return p
         .          .     71:}
         .          .     72:

我们能够发现最多的损耗花在了reflect.New()上，我们着手尝试对它进行优化。

干掉 reflect.New()

池化

对于改善创建对象耗时来说，最简单的优化方式便是池化，我们利用sync.pool创建一个对象池，并且模拟对象池中资源充足的情况下的性能：


var (
  /**
  ...........
  **/
  pool sync.Pool
)
func init() {
  /**
  ............
  **/
    pool.New = func() interface{} {
        return reflect.New(t)
    }
    for i := 0; i < 100; i++ {
        pool.Put(reflect.New(t).Elem())
    }
}

/**
  ............
  **/

func NewQuickReflectWithPool() interface{} {
    p := pool.Get()

    ptr0 := uintptr((*emptyInterface)(unsafe.Pointer(&p)).word)
    ptr1 := ptr0 + offset1
    ptr2 := ptr0 + offset2
    ptr3 := ptr0 + offset3

    *((*int)(unsafe.Pointer(ptr0))) = 18
    *((*string)(unsafe.Pointer(ptr1))) = "shiina"
    *((*string)(unsafe.Pointer(ptr2))) = "test1"
    *((*string)(unsafe.Pointer(ptr3))) = "test2"
    return p
}

func BenchmarkQuickReflectWithPool(b *testing.B) {
    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        obj := NewQuickReflectWithPool()
        pool.Put(obj)
    }
}

在上述这个用例中，我们一拿到这个对象几乎就立即放回了对象池，模拟的是对象池资源充足情况下的性能：


BenchmarkNew
BenchmarkNew-16                         1000000000           1.26 ns/op        0 B/op          0 allocs/op
BenchmarkNewUseReflect
BenchmarkNewUseReflect-16                5515128           226 ns/op          64 B/op          1 allocs/op
BenchmarkNewQuickReflect
BenchmarkNewQuickReflect-16             21561645            91.4 ns/op        64 B/op          1 allocs/op
BenchmarkQuickReflectWithPool
BenchmarkQuickReflectWithPool-16        40770750            55.6 ns/op         0 B/op          0 allocs/op

我们可以发现在对象池对象充足的情况下，没有了malloc带来的耗时，我们的性能从原生72倍提升到原生的44倍。

但是当对象池不充足情况下，就没有这么可喜的效率了。

另一个思路

我们能够发现现在主要的耗时都在利用反射的创建对象上，这个时候我脑海里有一个思路：

在我们需要的是值类型(例如Person{})，而不是指针的时候(例如&Person)时，我们是不是可以利用Go的这个特性：

值类型传递值而不是指针的时候会进行拷贝

来在使用反射的前提下，利用值传递特性获得一个原生级别对象拷贝？

如果不使用反射，已知类型的情况下会是如下的代码：


func TestStruct(t *testing.T) {
    p1 := People{}

    var p2 interface{}
    p2 = p1

    ptr0 := uintptr((*emptyInterface)(unsafe.Pointer(&p2)).word)
    ptr1 := ptr0 + offset1
    ptr2 := ptr0 + offset2
    ptr3 := ptr0 + offset3

    *((*int)(unsafe.Pointer(ptr0))) = 18
    *((*string)(unsafe.Pointer(ptr1))) = "shiina"
    *((*string)(unsafe.Pointer(ptr2))) = "test1"
    *((*string)(unsafe.Pointer(ptr3))) = "test2"

    fmt.Println(p1)
    fmt.Println(p2)
}
------------------------
{0   }
{18 shiina test1 test2}

我们可以看到，我们使用这样一个值传递的特性，得到了一份p1的拷贝

很可惜的是，当我们不能直接指定类型的时候，想象中这样场景一直实现不了，会直接修改原变量的值，最终我找到了这样的调用方法：


func TestNew(t *testing.T) {
    elemValue := reflect.New(reflect.TypeOf(People{})).Elem()
    p := elemValue.Interface()

    ptr0 := uintptr((*emptyInterface)(unsafe.Pointer(&p)).word)
    ptr1 := ptr0 + offset1
    ptr2 := ptr0 + offset2
    ptr3 := ptr0 + offset3

    *((*int)(unsafe.Pointer(ptr0))) = 18
    *((*string)(unsafe.Pointer(ptr1))) = "shiina"
    *((*string)(unsafe.Pointer(ptr2))) = "test1"
    *((*string)(unsafe.Pointer(ptr3))) = "test2"

    fmt.Println(p)
    fmt.Println(elemValue)
}
-------------------
{18 shiina test1 test2}
{0   }

每次elemValue.Interface()时都会拷贝一个新的对象，这是我们期待的结果，接下来我们将它和之前的池化等一起进行性能测试


BenchmarkNew
BenchmarkNew-16                         1000000000           1.83 ns/op        0 B/op          0 allocs/op
BenchmarkNewUseReflect
BenchmarkNewUseReflect-16                2992928           372 ns/op         128 B/op          2 allocs/op
BenchmarkNewQuickReflect
BenchmarkNewQuickReflect-16             12648523            98.7 ns/op        64 B/op          1 allocs/op
BenchmarkQuickReflectWithPool
BenchmarkQuickReflectWithPool-16        40309711            58.2 ns/op         0 B/op          0 allocs/op
BenchmarkNewWithElemReflect
BenchmarkNewWithElemReflect-16          12700314            89.0 ns/op        64 B/op          1 allocs/op

结果比较沮丧，我们仅提升了不到10ns，从53倍提升到48倍，并且性能的提升也并不稳定。

为此我们阅读reflect.New()和elemValue.Interface()源码，发现了如下的片段：

reflect.New()


func New(typ Type) Value {
	if typ == nil {
		panic("reflect: New(nil)")
	}
	t := typ.(*rtype)
	ptr := unsafe_New(t)
	fl := flag(Ptr)
	return Value{t.ptrTo(), ptr, fl}
}

elemValue.Interface()


if v.flag&flagAddr != 0 {
   // TODO: pass safe boolean from valueInterface so
   // we don't need to copy if safe==true?
   c := unsafe_New(t)
   typedmemmove(t, c, ptr)
   ptr = c
}

reflect.New()的主要耗时都在这个unsafe_New()函数上，然而对于一个elemValue取Interface()时，反射还是会调用unsafe_New()函数来创建一个新值。

当多次实验，性能测试之后，发现这种干掉reflect.New()的方式性能不够稳定，基本没有使用的必要。( T_T )

END

如上整个性能优化的从思路到实验，再到实现大概总共花了一周的空闲时间。越写越觉得我不像是在写Go而是在写c了。或许我应该让Go写的更像Go而不是想什么黑魔法来让Go更快(也更不安全)？很感谢需求不饱和让我还有摸鱼时间来研究这个(x

发表于: 2020-09-212020-09-21 14:28:59
本文为 InfoQ 中文站特供稿件
首发地址：https://www.infoq.cn/article/54c8443155808e3abbc558fc4
如有侵权，请联系 cloudcommunity@tencent.com 删除。

扫码

添加站长进交流群

领取专属 10元无门槛券

私享最新 技术干货

Golang 反射性能优化

简单的性能测试

性能损耗的猜测

干掉 value.Field().Set()

unsafe

操作结构体

结构体类型强转

干掉 reflect.New()

池化

另一个思路

END

相关快讯

扫码

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐