逃逸分析
问题
什么是逃逸分析？Go 编译器如何决定变量分配在栈还是堆？
答案
什么是逃逸分析
逃逸分析（Escape Analysis）是 Go 编译器在编译阶段进行的静态分析。如果编译器能证明一个变量的生命周期不超过函数范围，就把它分配在栈上；否则"逃逸"到堆上。
栈分配不需要 GC，性能极好。所以逃逸分析的目标是：尽量让变量留在栈上。
查看逃逸分析结果
go build -gcflags="-m" main.go
# -m: 输出逃逸分析结果
# -m -m: 更详细的输出
go build -gcflags="-m -l" main.go
# -l: 禁用内联（看更真实的逃逸情况）
输出示例：
./main.go:8:6: moved to heap: x // x 逃逸到堆
./main.go:12:10: &x escapes to heap // 取 x 地址导致逃逸
./main.go:16:6: s does not escape // s 没有逃逸
常见逃逸场景
1. 返回局部变量的指针
// ❌ x 逃逸到堆
func newInt() *int {
x := 42 // x 本应在栈上
return &x // 但返回了指针，函数结束后指针仍有效，必须在堆上
}
// ✅ 不逃逸
func copyInt() int {
x := 42
return x // 值拷贝，x 不逃逸
}
2. 赋值给 interface{}
// ❌ 逃逸
func print(a any) { // any = interface{}
fmt.Println(a)
}
func main() {
x := 42
print(x) // x 被装箱为 interface{}，逃逸到堆
}
3. 发送到 Channel
// ❌ 逃逸（Channel 传递的数据必须在堆上）
ch := make(chan *Data)
d := &Data{Name: "test"}
ch <- d // d 逃逸
4. 闭包引用
// ❌ 逃逸
func closure() func() int {
x := 0
return func() int {
x++ // 闭包引用了 x
return x // x 逃逸到堆
}
}
5. Slice/Map 扩容
// 编译时确定大小不逃逸
s := make([]int, 10) // 栈上（小且编译时已知大小）
// ❌ 运行时确定大小可能逃逸
n := getSize()
s := make([]int, n) // 逃逸（编译时不知道 n 的值）
// ❌ 太大逃逸
s := make([]int, 100000) // 逃逸（超过栈帧大小限制）
6. 超大局部变量
// ❌ 逃逸
func bigArray() {
var arr [1 << 20]int // 8MB 数组，太大无法放栈上
_ = arr
}
逃逸分析的局限
Go 的逃逸分析是保守的——宁可错误地逃逸（堆分配），也不会错误地不逃逸（导致悬挂指针）。
不能优化的场景：
interface{}参数——编译器不知道具体类型reflect——运行时操作cgo——跨越 Go/C 边界
优化策略
// 1. 尽量返回值而不是指针
func good() Config { return Config{} } // ✅ 不逃逸
func bad() *Config { return &Config{} } // ❌ 逃逸
// 2. 避免不必要的 interface{}
func sum(a, b int) int { return a + b } // ✅ 不逃逸
func sum(a, b any) any { ... } // ❌ 逃逸
// 3. 预分配足够的 slice
buf := make([]byte, 0, 1024) // ✅ 已知大小在栈上
// 4. 用 sync.Pool 复用堆对象
var pool = sync.Pool{New: func() any { return new(bytes.Buffer) }}
常见面试问题
Q1: 为什么 Go 不让开发者手动决定栈/堆分配？
答案：
Go 的设计理念是简单和安全。手动内存管理（如 C/C++）容易出错（悬挂指针、内存泄漏、double free）。Go 通过编译器逃逸分析自动决定，既保证安全，又能优化性能。
Q2: 逃逸到堆上有什么坏处？
答案：
- GC 压力增大：堆上的对象需要 GC 扫描和回收
- 分配速度变慢：堆分配需要从 mcache→mcentral→mheap，比栈分配（移动指针）慢
- 缓存不友好：堆对象分散在内存中，CPU 缓存命中率低
Q3: 如何判断一段代码是否有不必要的堆分配？
答案：
# 1. 逃逸分析
go build -gcflags="-m" ./...
# 2. Benchmark 查看分配次数
func BenchmarkXxx(b *testing.B) {
b.ReportAllocs() // 报告每次操作的分配次数
for i := 0; i < b.N; i++ { /* ... */ }
}
# 3. pprof 查看热点分配
go tool pprof -alloc_objects http://localhost:6060/debug/pprof/heap
Q4: 返回结构体和返回结构体指针在性能上有什么区别？
答案：
func byValue() Config { return Config{...} } // 值拷贝，栈分配
func byPointer() *Config { return &Config{...}} // 指针返回，堆分配
- 小结构体（< 几百字节）：值返回更快（栈分配 + 内联优化）
- 大结构体（> 几 KB）：指针返回更好（避免大量复制开销）
- 编译器内联后，值返回有时零拷贝（直接在调用方栈帧构造）