go 中高性能编程是一个经久不衰的话题，本文尝试从实践及源码层面对 go 的高性能编程进行解析。
1. 为什么要进行性能优化
服务上线前，为什么要进行压测和性能的优化？
一个例子，content-service 在压测的时候发现过一个问题: 旧逻辑为了简化编码，在进行协议转换前，会对某些字段做一个 DeepCopy，因为转换过程需要原始数据，但我们完全可以通过一些处理逻辑的调整，比如调整先后顺序等移除 DeepCopy。优化前后性能对比如下：
性能有 7 倍左右提升，改动很小，但折算到成本上的收益是巨大的。
在性能优化上任何微小的投入，都可能会带来巨大的收益
那么，如何对 go 程序的性能进行度量和分析？
2. 度量和分析工具
2.1 Benchmark
2.1.1 Benchmark 示例
函数固定以 Benchmark 开头，其位于_test.go 文件中，入参为 testing.B业务逻辑应放在 for 循环中，因为 b.N 会依次取值 1, 2, 3, 5, 10, 20, 30, 50,100.........，直至执行时间超过 1s
可通过命令执行 benchmark，其结果如下:
， 要执行的 benchmark。需注意:该参数支持模糊匹配，如--bench='Get|Set' ，支持./...，只进行 Benchmark，不执行单测
BenchmarkConvertReflect, 在 1s 内执行了 520200014 次，每次约 2.291ns
2.1.2 高级用法
， 依次递增 b.N 直至运行时间超过 2s，执行 3 轮，展示堆分配信息，0 B/op, 0 allos/op 分别代表每次分配了多少空间，每个 op 有多少次空间分配，依次在 2 核、4 核下进行测试，benmark 时生成 profile、trace 文件，停止编译器的内联优化，重置定时器， 并发执行，设置并发的协程数
目前对 go 性能进行分析的主要工具包含:profile、trace，以下是对二者的介绍
2.2 profile
目前 go 中 profile 包括: cpu、heap、mutex、goroutine。要在 go 中启用 profile 主要有以下几种方式:
运行时函数，如 pprof.StartCPUProfile、pprof.WriteHeapProfile 等
导入 net/http/pprof 包
go test 中使用-cpuprofile、-memprofile
go 中提供了 pprof 工具对 profile 进行解析，以 cpuprofile 为例，如下：
分别代表了当前函数、当前函数调用函数的统计信息是用的最多的命令
go 也提供了 web 界面用以对各种调用进行图像化展示，可以通过-http 打开内置的 http 服务，该服务可以展示包含调用图、火焰图等信息
对于调用图，边框、字体的颜色越深，代表消耗资源越多。实线代表直接调用，虚线代表非直接调用（中间还有其他调用）火焰图代表了调用层级，函数调用栈越长，火焰越高。同一层级，框越长、颜色越深占用资源越多profile 是通过采样实现，存在精度问题、且会对性能有影响(比如 go routine 的 profile 采样会导致 STW)
此外，目前 123 中已经有 profile 相关的插件，具体可搜索:
2.3 trace
profile 可以通过采样，确定系统运行中的热点，但其基于采样的处理也有精度等问题。 因此，go 提供了 trace 工具，其基于事件的统计为解决问题提供了更详细的数据，此外 go trace 还把 P、G、Heap 等相关信息聚合在一起按照时间进行展示，如下图：
go 中启用 trace，可以通过以下方式：
通过 runtime/trace 包中相应函数，主要是 trace.Start、trace.Stop
通过导入 net/http/pprof
通过 go test 中 trace 参数
以 runtime/trace 为例，如下：
，会打开页面，结果包含如下信息：
实际中经常先通过 Goroutine analysis、Scheduler latency profile 等查找可能的问题点，再通过 View trace 进行全面分析。
3. 常用类型和结构
3.1 interface、reflect
通常 go 中较多的 interface、reflect 会对性能有一定影响，interface、reflect 为什么会对性能有影响？
3.1.1 interface 和 eface
go 中 interface 包含 2 种，eface、iface。eface 用于标识不含方法的 interface，iface 用于标识带方法的 interface，其相关机制不在本文介绍范围。
eface 的定义位于runtime2.go、type.go，其定义如下：
因为同时包含类型、数据，go 中所有类型都可以转换为 interface。go 中为 interface 赋值的过程，即为 eface 变量生成的过程，通过汇编可以发现，其主要通过 convT*完成位于iface.go，具体分发逻辑位于convert.go。 以指针类型为例，其转换逻辑如下:
很多对 interface 类型的赋值(并非所有)，都会导致空间的分配和拷贝，这也是 Interface 函数为什么可能会导致逃逸的原因go 这么做的主要原因：逃逸的分析位于编译阶段，对于不确定的类型在堆上分配最为合适。
3.1.2 Reflect.Value
go 中 reflect 机制涉及到 2 个类型，reflect.Type 和 reflect.Value，reflect.Type 是一个 Interface，其不在本章介绍范围内。
reflect.Value 定义位于value.go、type.go，其定义与 eface 类似：
reflect.Value 是通过 reflect.ValueOf 获得，reflect.ValueOf 也会导致数据逃逸(interface 接口)，其定义位于value.go中，如下:
reflect.ValueOf 仍然会导致逃逸，但其逃逸还是由 interface 的入参导致
一个简单的例子：
结果如下：
需要注意，
3.1.3 类型的选择：interface、强类型如何选
为降低不必要的空间分配、拷贝，建议只在必要情况下使用 interface、reflect，针对函数定义，测试如下：
强类型函数调用性能远优于基于 interface 的调用，优化后 content-service 只使用了少量的 interface。
目前一些常用的基于 interface(可能会导致逃逸)的函数:
3.1.4 类型转换: 强转 vs 断言 vs reflect
目前 go 中数据类型转换，存在以下几种方式：
强转，如 int 转 int64，可用 int64(intData)。强转是对底层数据进行语意上的重新解释
断言(interface)，根据已有信息，对变量类型进行断言，如 interfaceData.(int64)，会利用 eface.type 中相关信息，对类型进行校验、转换。
reflect 相关函数，如 reflect.Valueof(intData).Int()，其中 intData 可以为各种 int 相关类型，具有较大的灵活性。
针对此的测试如下：
可以看出性能上：强类型转换/assert>reflect没有逃逸的原因参见:iface.go
content-service 中已经不再使用 reflect 相关的转换处理
3.2 常用 map
go 中常用的 map 包含，runtime.map、sync.map 和第三方的 ConcurrentMap，go 中 map 的定义位于map.go，典型的基于 bucket 的 map 的实现，如下：
sync.map 定义位于map.go中，其是典型的以空间换时间的处理，具体如下:
read 中存储的是 dirty 数据的一个副本(通过指针)，在读多写少的情况下，基本可以实现无锁的数据读取。
Sync.map 相关机制参见:https://juejin.cn/post/6844903895227957262
go 中还有一个第三方的 ConcurrentMap，其采用分段锁的原理，通过降低锁的粒度提升性能，参见:current-map
针对 map、sync.map、ConcurrentMap 的测试如下：
需要注意此测试，读写并发比 20:1读多写少，建议使用 sync.Map。如果业务场景中，很明确只有对 map 的读操作，建议使用 runtime.Map
目前 content-service 中 runtime.map、sync.map 都有涉及
3.3 hash 的实现: index vs map
在使用到 hash 的场景，除了 map，我们还可以基于 slice 或者数组的索引，content-service 基于此实现另外一种 map。其性能对比如下：
性能有 5 倍左右提升，content-service 在解析正排数据时，即采用此种处理。
3.4 string 和 slice
3.4.1 string 和 slice 的定义
在 go 中 string、slice 都是基于 buf、len 的定义，二者定义都位于value.go中:
通过二者定义可以得出：
在值拷贝背景下，string、slice 的赋值操作代价都不大，最多有 24Byte
slice 因为涉及到 cap，会涉及到预分配、惰性删除，其具体位于slice.go
3.4.2 String、[]byte 转换
go 中 string 和[]byte 间相互转换包含 2 种：
采用原生机制，比如 string 转 slice 可采用，[]byte(strData)
基于对底层数据结构重新解释
以 string 转换为 byte 为例，原生转换的转换会进行如下操作，其位于string.go中：
其中 tmpBuf 定义为 type tmpBuf [32]byte。当长度超过 32 字节时，会进行空间的分配、拷贝
同理，byte 转换为 string，原生处理位于 slicebytetostring 函数，也位于string.go中
针对多余的空间分配、拷贝问题，content-service 对此进行了封装，具体参见tools.go，该实现通过对底层数据重新解释进行，具有较高的效率。
以 byteToString 为例，相关 benchMark 如下：
其性能有较大提升，需要注意，本处理只针对转换，不涉及 append 等可能引起扩容的处理
3.4.3 string 的拼接
当前 golang 中字符串拼接方式，主要包含：
使用+连接字符串
使用 fmt.Sprintf
使用运行时工具类，strings.Builder 或者 bytes.Buffer
预分配机制
目前对+的处理，其处理函数位于string.go，当要连接的字符串长度>32 时，每次会进行空间的分配和拷贝处理，其处理如下：
fmt.Sprinf，涉及大量的 interface 相关操作，会导致逃逸。
针对+、fmt.Sprintf 等的对比测试如下：
可以看出，空间预分配拥有非常高的性能指标。目前，Content-service 中都采用了空间预分配的方式，其他的一些测试参见：string 连接
3.5 循环的处理： for vs range
go 中常用的循环有 2 种 for 和 range,如下：
按位置进行遍历，for 和 range 都支持，如 for i:=range a{}， for i:=0;i
同时对位置、值进行遍历，range 支持，如 for i,v := range a {}
go 中循环经过一系列的编译、优化后，伪代码如下：
此处理可能会导致以下问题：
遍历前，会进行值的拷贝，如果是数组，会有大量数据拷贝，slice 和 map 等引用的拷贝较少
for range value 在遍历中存在对容器元素的拷贝
遍历开始，已经确定了容器长度，中间添加的数据，不会遍历到
针对此测试如下：
注意，对于所需空间较小，如指针类型数组等此问题并不严重在需要较大存储空间、元素需要较大存储空间时，建议不要采用 range value 的方式
content_service 中目前基本都是基于 for index、range index 的处理
3.6 重载
目前 go 中重载的实现包含 2 种，泛型(1.18)、基于 interface 的定义。泛型的优点在于预编译，即编译期间即可确定类型，对比基于 interface 的逃逸会有一定收益，具体测试如下：
对比 interface 类型的处理，泛型有一定的性能的提升，目前在 content-service 中已经得到了大量的使用。
4 空间与布局
4.1 栈与堆空间的分配
在栈上分配空间为什么会比堆上快？
通过汇编，可观察栈空间分配机制，如下：
其对应汇编代码如下：
在 go 中栈的扩容、释放只涉及到了 SUBQ、ADDQ 2 条指令。
其中，直接从 p.mcache 获取空间不需要加锁（单协程），mheap.mcentral 获取空间需要加锁(全局变量)、mmap 需要系统调用。此外，堆上分配还需要考虑 gc 导致的 stw 等的影响，因此建议所需空间不是特别大时还是在栈上进行空间的分配。
content-service 开发中有一个共识: 能在栈上处理的数据，不会放到堆上。
4.2 Zero GC
Zero GC 能够避免 gc 带来的扫描、STW 等，具有一定的性能收益。
当前 zero gc 的处理，主要包含 2 种：
无 gc，通过 mmap 或者 cgo.malloc 分配空间，绕过 go 的内存分配机制，如 fastcache 的实现
避免或者减少 gc，通过[]byte 等避免因为指针导致的扫描、stw，bigCache 的实现即为此。
Zero GC 的优点在于，避免了 go gc 处理带来的标记扫描、STW 等，相对于常规堆上数据分配，其性能有较大提升。content-service 在重构中，使用了大量的基于 0 gc 的库，比如 fastcache，对一些常用函数、机制，如 strings.split 也进行了 0 gc 的优化，其实现如下：
在 content-service 中其实现位于string_util.go，如下:
与常规 strings.split 对比如下，其性能有近 4 倍左右提升：
4.3 GC 的优化
需要注意，此机制只在 1.20 以上版本生效
4.4 逃逸
对于一些处理比较复杂操作，go 在编译器会在编译期间将相关变量逃逸至堆上。目前可能导致逃逸的机制包含:
基于指针的逃逸
栈空间不足，超过了 os 的限制 8M
闭包
动态类型
目前逃逸分析，可采用-gcflags=-m 进行查看，如下:
在日常业务处理过程中，建议尽量避免逃逸到堆上的情况
4.5 数据的对齐
go 中同样存在数据对齐，适当的布局调整，能够节省大量的空间，具体如下：
4.6 空间预分配
空间预分配，可以避免大量不必要的空间分配、拷贝，目前 slice、map、strings.Builder、byte.Builder 等都涉及到预分配机制。
以 map 为例，测试结果如下：
预分配能够极大提升，相关性能， 建议在使用时都进行空间的预分配。content-service 在开发中基本都做到了空间的预分配。
5 并发编程
5.1 锁
golang 中 mutex 定义位于mutex.go，其定义如下：
golang 的读写锁基于 mutex，其定义位于rwmutex.go, 其定义如下:
RWMutex 基于 Mutex 实现，在加写锁上，RWMutex 性能略差于 Mutex。但在读操作较多情况下，RWMutex 性能是优于 Mutex 的，因为 RWMutex 对于读的操作只是通过 readerCount 计数进行， 其相关处理位于rwmutex.go，如下:
按照读写比例的不同，进行了如下测试：
在读写比例为 9:1 时，RWMute 性能约为 Mutex 的 6 倍。
6. 其他
需要注意：
本文所有 benchmark、源码都是基于 1.18。
7. 参考资料
go 高性能编程
go 语言设计与实现
go 专家编程
go 语言底层原理剖析