Go 高手（06）：闭包与逃逸分析——变量捕获、生命周期、性能
更新时间：2026-09-01。本文是
languages/go/intermediate/高手层第 6 篇，接 defer 底层机制。闭包（closure）是 Go 里常用的语言特性，但闭包捕获变量会让变量逃逸到堆，影响 GC 压力。理解闭包和逃逸分析，是写出高性能 Go 代码的关键。
本文要回答的问题
- 闭包捕获变量时，变量在栈上还是在堆上？
- 逃逸分析是什么？怎么查看逃逸分析结果？
- for 循环变量捕获的经典 bug 是什么？Go 1.22 修了没有？
- 什么情况下变量会逃逸到堆？怎么避免不必要的逃逸？
一、闭包捕获：值 vs 引用
func newCounter() func() int {
n := 0
return func() int {
n++ // 捕获 n
return n
}
}
counter := newCounter()
fmt.Println(counter()) // 1
fmt.Println(counter()) // 2n 被闭包捕获后，会逃逸到堆上，因为闭包返回后栈帧会被销毁，但 n 还要继续存在（被闭包引用着）。
二、逃逸分析：栈还是堆？
Go 编译器通过逃逸分析决定变量分配在栈还是堆上。规则很简单：如果变量在函数返回后仍然被引用，就逃逸到堆。
// 不逃逸：变量在栈上
func sum() int {
x := 42
return x // x 不会被函数外引用
}
// 逃逸：变量在堆上
func newInt() *int {
x := 42
return &x // x 被返回，函数外还能用
}查看逃逸分析结果：
go build -gcflags="-m" 2>&1
# 输出类似：
# ./main.go:10:6: can inline sum
# ./main.go:14:2: moved to heap: x三、for 循环变量捕获（经典 bug）
// ❌ Go 1.21 及之前：经典的 bug
func main() {
var funcs []func()
for i := 0; i < 3; i++ {
funcs = append(funcs, func() {
fmt.Println(i) // 捕获的 i 是同一个变量
})
}
for _, f := range funcs {
f()
}
}
// 输出：3 3 3 （而不是 0 1 2）原因：在 Go 1.21 之前，循环变量 i 只有一个，闭包捕获的是同一个 i 的引用，循环结束后 i 是 3。
修复方式（Go 1.21 之前）：
for i := 0; i < 3; i++ {
i := i // 创建副本
funcs = append(funcs, func() {
fmt.Println(i) // 捕获的是副本
})
}Go 1.22 已修复：从 Go 1.22 开始，for range 和 for i 每次迭代都创建新的循环变量，直接输出 0 1 2。
四、逃逸分析的常见场景
// 1. 返回指针 → 逃逸 ✅
func newPerson(name string) *Person {
p := Person{Name: name}
return &p // 逃逸
}
// 2. 大的结构体通过值传递 → 不逃逸
func process(p Person) {
// 虽然 Person 大，但值传递不会逃逸
}
// 3. 接口不确定 → 可能逃逸
func print(v any) {
fmt.Println(v) // 接口参数，可能逃逸
}
// 4. 闭包捕获 → 逃逸
func do(f func()) {
f()
}五、避免不必要的逃逸
// ❌ 逃逸：传入接口，编译器不确定具体类型
func format(v any) string {
return fmt.Sprintf("value: %v", v)
}
// ✅ 不逃逸：用具体类型
func formatInt(v int) string {
return fmt.Sprintf("value: %d", v)
}但实际上，在性能敏感的代码里才需要操心逃逸。普通代码不用担心——编译器比你聪明。逃逸分析的主要目标是减少 GC 压力，不是减少逃逸本身。
六、闭包 vs 函数 + 参数的性能
// 方式一：闭包
func doLater(f func()) {
f()
}
// 方式二：函数 + 参数
func doLater(f func(int), x int) {
f(x)
}方式一如果闭包捕获了外部变量，会导致变量逃逸。方式二用参数传递，不会逃逸。在热路径上，方式二性能更好。
七、常见坑对照
| 坑 | 现象 | 对策 |
|---|---|---|
| for 循环闭包捕获循环变量 | 所有闭包拿到最后一个值 | Go 1.22 已修复，或用 i := i 创建副本 |
| 闭包导致变量逃逸 | 堆分配增加，GC 压力 | 热路径用参数代替闭包 |
| 大结构体值传递 | 不逃逸但拷贝成本高 | 值传递不逃逸，拷贝成本看场景 |
| 返回局部指针 | 逃逸到堆，但不一定就是坏事 | 逃逸不一定有害，要结合 GC 看 |
相关与延伸
下一篇：slice 底层——slice header、扩容策略、内存泄漏；逃逸分析和 GC 的关系，见 GC 与逃逸分析；查看逃逸分析用
go build -gcflags="-m"。
一句话总结
闭包与逃逸分析：闭包捕获的变量会逃逸到堆上，因为函数返回后闭包仍然引用着它；go build -gcflags="-m" 查看逃逸分析结果；for 循环变量捕获是 Go 经典 bug，Go 1.22 已修复；逃逸不一定是坏事，热路径上才需要关心；用参数传递代替闭包捕获可以避免不必要的逃逸。