Go基础—反射，性能和灵活性的双刃剑_go语言反射——性能和灵活性的双刃剑(1)

最新推荐文章于 2024-10-10 10:27:34 发布

2401_84925335

最新推荐文章于 2024-10-10 10:27:34 发布

阅读量889

点赞数 27

文章标签： go 学习面试

本文链接：https://blog.csdn.net/2401_84925335/article/details/138937681

版权

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

第 2 行，声明一个普通结构体，拥有一个成员变量。
第 6 行，使用基准化测试的入口。
第 9 行，实例化 data 结构体，并给 Hp 成员赋值。
第 12～17 行，由于测试的重点必须放在赋值上，因此需要极大程度地降低其他代码的干扰，于是在赋值完成后，将基准测试的计时器复位并重新开始。
第 20 行，将基准测试提供的测试数量用于循环中。
第 23 行，测试的核心代码：结构体赋值。

接下来的代码分析使用反射访问结构体成员并赋值的过程。

func BenchmarkReflectAssign(b \*testing.B) {

    v := data{Hp: 2}

    // 取出结构体指针的反射值对象并取其元素
    vv := reflect.ValueOf(&v).Elem()

    // 根据名字取结构体成员
    f := vv.FieldByName("Hp")

    b.StopTimer()
    b.ResetTimer()
    b.StartTimer()

    for i := 0; i < b.N; i++ {

        // 反射测试设置成员值性能
        f.SetInt(3)
    }
}

代码说明如下：

第 6 行，取v的地址并转为反射值对象。此时值对象里的类型为 *data，使用值的 Elem() 方法取元素，获得 data 的反射值对象。
第 9 行，使用 FieldByName() 根据名字取出成员的反射值对象。
第 11～13 行，重置基准测试计时器。
第 18 行，使用反射值对象的 SetInt() 方法，给 data 结构的Hp字段设置数值 3。

这段代码中使用了反射值对象的 SetInt() 方法，这个方法的源码如下：

func (v Value) SetInt(x int64) {
    v.mustBeAssignable()
    switch k := v.kind(); k {
    default:
        panic(&ValueError{"reflect.Value.SetInt", v.kind()})
    case Int:
        \*(\*int)(v.ptr) = int(x)
    case Int8:
        \*(\*int8)(v.ptr) = int8(x)
    case Int16:
        \*(\*int16)(v.ptr) = int16(x)
    case Int32:
        \*(\*int32)(v.ptr) = int32(x)
    case Int64:
        \*(\*int64)(v.ptr) = x
    }
}

可以发现，整个设置过程都是指针转换及赋值，没有遍历及内存操作等相对耗时的算法。

3 结构体成员搜索并赋值对比

func BenchmarkReflectFindFieldAndAssign(b \*testing.B) {

    v := data{Hp: 2}

    vv := reflect.ValueOf(&v).Elem()

    b.StopTimer()
    b.ResetTimer()
    b.StartTimer()

    for i := 0; i < b.N; i++ {

        // 测试结构体成员的查找和设置成员的性能
        vv.FieldByName("Hp").SetInt(3)
    }

}

这段代码将反射值对象的 FieldByName() 方法与 SetInt() 方法放在循环里进行检测，主要对比测试FieldByName()方法对性能的影响。FieldByName()方法源码如下：

func (v Value) FieldByName(name string) Value {
    v.mustBe(Struct)
    if f, ok := v.typ.FieldByName(name); ok {
        return v.FieldByIndex(f.Index)
    }
    return Value{}
}

底层代码说明如下：

第 3 行，通过名字查询类型对象，这里有一次遍历过程。
第 4 行，找到类型对象后，使用 FieldByIndex() 继续在值中查找，这里又是一次遍历。

经过底层代码分析得出，随着结构体字段数量和相对位置的变化，FieldByName() 方法比较严重的低效率问题。

4 调用函数对比

反射的函数调用，也是使用反射中容易忽视的性能点，下面展示对普通函数的调用过程。

// 一个普通函数
func foo(v int) {

}

func BenchmarkNativeCall(b \*testing.B) {

    for i := 0; i < b.N; i++ {
        // 原生函数调用
        foo(0)
    }
}

func BenchmarkReflectCall(b \*testing.B) {

    // 取函数的反射值对象
    v := reflect.ValueOf(foo)

    b.StopTimer()
    b.ResetTimer()
    b.StartTimer()

    for i := 0; i < b.N; i++ {
        // 反射调用函数
        v.Call([]reflect.Value{reflect.ValueOf(2)})
    }
}

代码说明如下：

第 2 行，一个普通的只有一个参数的函数。
第 10 行，对原生函数调用的性能测试。
第 17 行，根据函数名取出反射值对象。
第 25 行，使用reflect.ValueOf(2)将2构造为反射值对象，因为反射函数调用的参数必须全是反射值对象，再使用[]reflect.Value构造多个参数列表传给反射值对象的Call()方法进行调用。

反射函数调用的参数构造过程非常复杂，构建很多对象会造成很大的内存回收负担。Call() 方法内部就更为复杂，需要将参数列表的每个值从reflect.Value类型转换为内存。调用完毕后，还要将函数返回值重新转换为reflect.Value类型返回。因此，反射调用函数的性能堪忧。

5 基准测试结果对比

测试结果如下：

$ go test -v -bench=.
goos: linux
goarch: amd64
BenchmarkNativeAssign-4                        2000000000               0.32 ns/op
BenchmarkReflectAssign-4                       300000000               4.42 ns/op
BenchmarkReflectFindFieldAndAssign-4           20000000               91.6 ns/op
BenchmarkNativeCall-4                          2000000000               0.33 ns/op
BenchmarkReflectCall-4                         10000000               163 ns/op
PASS

结果分析如下：