逃逸分析

题目描述

以下代码中，哪些变量会逃逸到堆上？为什么？

func A() *int {
    x := 42
    return &x  // x 会逃逸吗？
}

func B() {
    x := 42
    fmt.Println(x)  // x 会逃逸吗？
}

func C() {
    x := make([]int, 1000)
    _ = x[0]  // x 会逃逸吗？
}

func D() interface{} {
    x := 42
    return x  // x 会逃逸吗？
}

提示

• 返回局部变量的指针会逃逸
• 传递给 interface 参数可能逃逸
• 大对象可能逃逸
• 闭包捕获变量会逃逸

解法

# 查看逃逸分析结果
go build -gcflags="-m" main.go

func A() *int {
    x := 42
    return &x  // ✗ x 逃逸到堆
}

// 分析：
// 返回局部变量 x 的指针
// x 在函数返回后仍需访问
// 必须分配在堆上

func B() {
    x := 42
    fmt.Println(x)  // ✗ x 逃逸到堆
}

// 分析：
// fmt.Println 的参数是 interface{}
// x 被赋值给 interface{}
// interface{} 可能传递到其他地方
// x 逃逸到堆

func C() {
    x := make([]int, 1000)
    _ = x[0]  // ✓ 可能不逃逸（取决于编译器）
}

// 分析：
// 切片较大（8KB）
// 编译器可能判断栈空间不足
// 可能直接分配在堆上
// 或在栈上分配（Go 1.17+ 优化）

func D() interface{} {
    x := 42
    return x  // ✗ x 逃逸到堆
}

// 分析：
// 返回 interface{}
// x 的值需要存储在 interface 中
// interface 可能在函数外使用
// x 逃逸到堆

优化：避免不必要的逃逸

优化 1：返回值而非指针

// ❌ 逃逸
func NewUser() *User {
    return &User{Name: "Alice"}  // 逃逸到堆
}

// ✅ 不逃逸（小对象）
func NewUser() User {
    return User{Name: "Alice"}  // 栈分配
}

优化 2：预分配容量

// ❌ 多次扩容，可能逃逸
func Process() []int {
    s := make([]int, 0)
    for i := 0; i < 1000; i++ {
        s = append(s, i)  // 多次扩容
    }
    return s
}

// ✅ 预分配，减少扩容
func Process() []int {
    s := make([]int, 0, 1000)
    for i := 0; i < 1000; i++ {
        s = append(s, i)
    }
    return s
}

优化 3：避免闭包捕获

// ❌ 闭包捕获变量
func Process(items []int) []int {
    results := []int{}
    for _, item := range items {
        go func() {
            results = append(results, item*2)  // results 逃逸
        }()
    }
    return results
}

// ✅ 传递参数
func Process(items []int) []int {
    results := make([]int, 0, len(items))
    for i, item := range items {
        go func(idx int, val int) {
            results[idx] = val * 2
        }(i, item*2)
    }
    return results
}

优化 4：使用 sync.Pool

var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 1024)
    },
}

func Process() {
    buf := bufferPool.Get().([]byte)
    defer bufferPool.Put(buf)
    
    // 使用 buf
    // ...
}

查看逃逸分析

基本用法

# 查看逃逸分析
go build -gcflags="-m" main.go

# 更详细的分析
go build -gcflags="-m -m" main.go

# 只显示逃逸分析，不优化
go build -gcflags="-m -l" main.go

输出示例

# command-line-arguments
./main.go:10:6: can inline A as: func() int
./main.go:11:9: &x escapes to heap
./main.go:10:6: moved to heap: x
./main.go:15:6: can inline B as: func()
./main.go:16:13: ... argument does not escape
./main.go:16:13: x escapes to heap

解释

• &x escapes to heap：x 的引用逃逸到堆
• moved to heap: x：x 被移动到堆
• ... argument does not escape：参数未逃逸
• can inline：函数可以被内联

栈 vs 堆