Golang的反射最为人诟病的就是它极差的性能，接下来我们尝试优化它的性能。
如果我们使用正常的流程来创建一个对象，将会是如下的代码片段：
type People struct {Age intName string}func New() *People {return &People{Age: 18,Name: "shiina",}}
以上的代码非常好读，但是如果我们要开发一款框架，接收的类型非常有可能是动态的、不确定的，那么就会使用到反射(Reflect)功能，使用反射来创建一个如上的Person对象大概是如下的代码片段：
func NewUseReflect() interface{} {var p Peoplet := 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()}}
我们得到的测试结果如下：
BenchmarkNewBenchmarkNew-16 1000000000 1.55 ns/op 0 B/op 0 allocs/opBenchmarkNewUseReflectBenchmarkNewUseReflect-16 4787185 248 ns/op 64 B/op 2 allocs/op
性能损耗的猜测
那么反射创建对象，主要的性能损耗在哪里呢？我们先进行一个实验：
并且当我们增加更多的结构体成员变量，比如增加两个string类型的成员变量，进行一次性能测试，然后再去掉所有的成员变量，进行一次性能测试。
- 四个成员变量：
```go
type People struct {
Age int
Name string
Test1 string
Test2 string
}
func New() interface{} {
return &People{
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/opAge: 18,Name: "shiina",
- 无成员变量：```gotype People struct{}func New() interface{} {return &People{}}func NewUseReflect() interface{} {var p Peoplet := reflect.TypeOf(p)v := reflect.New(t)return v.Interface()}——————————————————————————————————————————BenchmarkNewBenchmarkNew-16 1000000000 1.32 ns/op 0 B/op 0 allocs/opBenchmarkNewUseReflectBenchmarkNewUseReflect-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.outType: cpuTime: 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.go60ms 2.17s (flat, cum) 64.97% of Total. . 29:10ms 10ms 30:func NewUseReflect() interface{} {. . 31: var p People10ms 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()
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 *rtypeword 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 int32b []byte}type Test2 struct {b int16a 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))=111fmt.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).Offsetoffset2 := typeP.Field(2).Offsetoffset3 := typeP.Field(3).Offsett2 := 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 uintptroffset2 uintptroffset3 uintptrp Peoplet = reflect.TypeOf(p))func init() {offset1 = t.Field(1).Offsetoffset2 = t.Field(2).Offsetoffset3 = t.Field(3).Offset}type People struct {Age intName stringTest1 stringTest2 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 + offset1ptr2 := ptr0 + offset2ptr3 := 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()}}
运行后我们的测试结果：
BenchmarkNewBenchmarkNew-16 1000000000 1.34 ns/op 0 B/op 0 allocs/opBenchmarkNewUseReflectBenchmarkNewUseReflect-16 3715539 276 ns/op 64 B/op 1 allocs/opBenchmarkNewQuickReflectBenchmarkNewQuickReflect-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.go120ms 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 + offset110ms 10ms 64: ptr2 := ptr0 + offset2. . 65: ptr3 := ptr0 + offset310ms 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 + offset1ptr2 := ptr0 + offset2ptr3 := 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)}}
在上述这个用例中，我们一拿到这个对象几乎就立即放回了对象池，模拟的是对象池资源充足情况下的性能：
BenchmarkNewBenchmarkNew-16 1000000000 1.26 ns/op 0 B/op 0 allocs/opBenchmarkNewUseReflectBenchmarkNewUseReflect-16 5515128 226 ns/op 64 B/op 1 allocs/opBenchmarkNewQuickReflectBenchmarkNewQuickReflect-16 21561645 91.4 ns/op 64 B/op 1 allocs/opBenchmarkQuickReflectWithPoolBenchmarkQuickReflectWithPool-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 = p1ptr0 := uintptr((*emptyInterface)(unsafe.Pointer(&p2)).word)ptr1 := ptr0 + offset1ptr2 := ptr0 + offset2ptr3 := 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 + offset1ptr2 := ptr0 + offset2ptr3 := 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()时都会拷贝一个新的对象，这是我们期待的结果，接下来我们将它和之前的池化等一起进行性能测试
BenchmarkNewBenchmarkNew-16 1000000000 1.83 ns/op 0 B/op 0 allocs/opBenchmarkNewUseReflectBenchmarkNewUseReflect-16 2992928 372 ns/op 128 B/op 2 allocs/opBenchmarkNewQuickReflectBenchmarkNewQuickReflect-16 12648523 98.7 ns/op 64 B/op 1 allocs/opBenchmarkQuickReflectWithPoolBenchmarkQuickReflectWithPool-16 40309711 58.2 ns/op 0 B/op 0 allocs/opBenchmarkNewWithElemReflectBenchmarkNewWithElemReflect-16 12700314 89.0 ns/op 64 B/op 1 allocs/op
结果比较沮丧，我们仅提升了不到10ns，从53倍提升到48倍，并且性能的提升也并不稳定。
为此我们阅读reflect.New()和elemValue.Interface()源码，发现了如下的片段：
- reflect.New()
```go
func New(typ Type) Value {
if typ == nil {
} t := typ.(*rtype) ptr := unsafe_New(t) fl := flag(Ptr) return Value{t.ptrTo(), ptr, fl} }panic("reflect: New(nil)")
- elemValue.Interface()```goif 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
作者：余歌
链接：https://juejin.cn/post/6844904150304555015
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
若有收获，就点个赞吧
0 人点赞
