Golang 逃逸分析（Escape Analysis）理解与实践篇
文章目录
-
-
- 1.逃逸分析
- 2.相关知识（栈、堆、GC分析）
- [3.逃逸分析综合-实践 demo](#3.逃逸分析综合-实践 demo)
-
逃逸分析（Escape Analysis）是编译器在编译期进行的一项优化技术，是Glang非常重要的性能优化工具。其目的是判断某个变量是否会被函数外部引用，或者超出其作用范围。
1.逃逸分析
如果变量仅在函数内部使用，那么它可以安全地分配在栈上；如果变量"逃逸"到函数外部（例如返回给调用者或者传递给其他协程），编译器会将其分配到堆上，以保证其生命周期不会在栈帧结束时被销毁。
1.返回指针：如果函数返回了局部变量的指针，该变量就会逃逸到堆上。
2.闭包捕获变量：闭包函数中捕获的外部变量也会导致变量逃逸。
3.接口类型的转换：接口转换时，如果具体类型需要被持久化存储，那么它可能逃逸。
4.动态分配的内存：例如使用 new 或者 make 创建的对象，编译器可能会决定将它们分配在堆上。
5.使用 Goroutine ：需要特别注意变量逃逸问题。因为 Goroutine 会并发执行，某些变量可能在 Goroutine 中被引用，导致它们逃逸到堆上。
Golang 提供了逃逸分析的工具（编译时查看函数中哪些变量发生了逃逸）：
bash
go build -gcflags="-m"2.相关知识（栈、堆、GC分析）
栈分配 ：栈是 Go 中快速分配和释放内存的区域。栈上的变量在函数返回时自动销毁，不需要额外的垃圾回收（GC）开销。
堆分配 ：堆上的内存分配速度相对较慢，且需要依赖 Go 的垃圾回收机制进行管理。频繁的堆分配会导致 GC 的频率增加，从而影响性能。
GC：Go 的垃圾回收器是三色标记清除算法，每次垃圾回收会对堆上的所有对象进行追踪和标记，回收不再使用的内存。
- 白色（待回收）：白色的对象表示未被访问到的对象。在垃圾回收开始时，所有的对象最初都被标记为白色。最终，所有仍然是白色的对象将被认定为不可达的，并在清除阶段被回收。
- 灰色（待处理）：灰色的对象表示已经被垃圾回收器访问到，但其引用的对象还没有完全处理。灰色对象需要进一步追踪其引用的对象。
- 黑色（已处理）：黑色的对象表示已经被处理过，它的引用对象也已经被追踪，不会被再次检查。黑色对象是安全的，表示它们依然在使用，不会被回收。
启用 GC 配置：
bash
export GOGC=50 # 设置 GOGC 为 50，增加 GC 频率，降低内存占用
export GODEBUG=gctrace=1 # GC 运行的详细信息，包括 GC 触发的时机、暂停时间、以及每次回收时清理的内存量GC 测试 demo：
go
package main
import (
"fmt"
"runtime"
"time"
)
func main() {
// 启动一个 Goroutine，持续分配内存，触发 GC
go func() {
for {
_ = make([]byte, 10<<20) // 每次分配 10MB 内存
time.Sleep(100 * time.Millisecond)
}
}()
// 打印内存使用情况和 GC 次数
var m runtime.MemStats
for i := 0; i < 10; i++ {
runtime.ReadMemStats(&m)
fmt.Printf("Alloc = %v MiB, Sys = %v MiB, NumGC = %v\n", m.Alloc/1024/1024, m.Sys/1024/1024, m.NumGC)
time.Sleep(1 * time.Second)
}
}3.逃逸分析综合-实践 demo
go
package main
import (
"fmt"
"runtime"
)
// 示例1：返回局部变量的指针
func escapeToHeap() *int {
a := 42
return &a // 逃逸到堆上，因为返回了局部变量的指针
}
// 示例2：闭包捕获外部变量
func closureExample() func() int {
x := 100
return func() int {
return x // x 逃逸到堆上，闭包捕获了外部变量
}
}
// 示例3：接口转换导致逃逸
func interfaceExample() {
var i interface{}
i = 42 // 逃逸到堆上，因为 interface 可能会持有较大对象
fmt.Println(i)
}
// 示例4：动态分配内存
func dynamicAllocation() {
p := new(int) // 逃逸到堆上，使用 new 分配内存
*p = 42
fmt.Println(*p)
}
// 示例5：在栈上分配
func noEscape() {
x := 42 // 没有逃逸，x 在栈上分配
fmt.Println(x)
}
// 示例6：Goroutine 中的逃逸分析
func goroutineEscape() {
x := 42
go func() {
fmt.Println(x) // x 逃逸到堆上，因为被 Goroutine 使用
}()
}
func main() {
// 打印当前内存使用情况
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("Initial Alloc = %v KB\n", m.Alloc/1024)
// 测试逃逸分析的各个示例
fmt.Println("Running escapeToHeap()")
escapeToHeap()
fmt.Println("Running closureExample()")
closure := closureExample()
fmt.Println(closure())
fmt.Println("Running interfaceExample()")
interfaceExample()
fmt.Println("Running dynamicAllocation()")
dynamicAllocation()
fmt.Println("Running noEscape()")
noEscape()
fmt.Println("Running goroutineEscape()")
goroutineEscape()
// 打印最终内存使用情况
runtime.ReadMemStats(&m)
fmt.Printf("Final Alloc = %v KB\n", m.Alloc/1024)
}编译-逃逸分析
bash
[jn@jn ~]$ go build -gcflags="-m" escape.go
# command-line-arguments
./escape.go:9:6: can inline escapeToHeap
./escape.go:15:6: can inline closureExample
./escape.go:17:9: can inline closureExample.func1
./escape.go:26:13: inlining call to fmt.Println
./escape.go:33:13: inlining call to fmt.Println
./escape.go:39:13: inlining call to fmt.Println
./escape.go:45:5: can inline goroutineEscape.func1
./escape.go:46:14: inlining call to fmt.Println
./escape.go:54:12: inlining call to fmt.Printf
./escape.go:57:13: inlining call to fmt.Println
./escape.go:58:14: inlining call to escapeToHeap
./escape.go:60:13: inlining call to fmt.Println
./escape.go:61:27: inlining call to closureExample
./escape.go:17:9: can inline main.func1
./escape.go:62:21: inlining call to main.func1
./escape.go:62:13: inlining call to fmt.Println
./escape.go:64:13: inlining call to fmt.Println
./escape.go:67:13: inlining call to fmt.Println
./escape.go:70:13: inlining call to fmt.Println
./escape.go:73:13: inlining call to fmt.Println
./escape.go:78:12: inlining call to fmt.Printf
./escape.go:10:2: moved to heap: a
./escape.go:17:9: func literal escapes to heap
./escape.go:25:2: 42 escapes to heap
./escape.go:26:13: ... argument does not escape
./escape.go:31:10: new(int) does not escape
./escape.go:33:13: ... argument does not escape
./escape.go:33:14: *p escapes to heap
./escape.go:39:13: ... argument does not escape
./escape.go:39:13: x escapes to heap
./escape.go:45:5: func literal escapes to heap
./escape.go:46:14: ... argument does not escape
./escape.go:46:14: x escapes to heap
./escape.go:54:12: ... argument does not escape
./escape.go:54:47: m.Alloc / 1024 escapes to heap
./escape.go:57:13: ... argument does not escape
./escape.go:57:14: "Running escapeToHeap()" escapes to heap
./escape.go:60:13: ... argument does not escape
./escape.go:60:14: "Running closureExample()" escapes to heap
./escape.go:61:27: func literal does not escape
./escape.go:62:13: ... argument does not escape
./escape.go:62:21: ~R0 escapes to heap
./escape.go:64:13: ... argument does not escape
./escape.go:64:14: "Running interfaceExample()" escapes to heap
./escape.go:67:13: ... argument does not escape
./escape.go:67:14: "Running dynamicAllocation()" escapes to heap
./escape.go:70:13: ... argument does not escape
./escape.go:70:14: "Running noEscape()" escapes to heap
./escape.go:73:13: ... argument does not escape
./escape.go:73:14: "Running goroutineEscape()" escapes to heap
./escape.go:78:12: ... argument does not escape
./escape.go:78:45: m.Alloc / 1024 escapes to heap
[jn@jn ~]$run
bash
[jn@jn ~]$ ./escape
Initial Alloc = 187 KB
Running escapeToHeap()
Running closureExample()
100
Running interfaceExample()
42
Running dynamicAllocation()
42
Running noEscape()
42
Running goroutineEscape()
Final Alloc = 190 KB
[jn@jn ~]$end
1.尽量避免将局部变量的指针返回给外部。
2.使用闭包时注意外部变量的捕获，避免逃逸。
3.尽量减少接口类型和 Goroutine 导致的逃逸。