如何知道对象分配在栈上还是堆上

面试官：请问 Golang 中如何知道对象分配在栈上还是堆上？

面试回答

在 Go 语言中，开发者无法直接指定对象分配在栈上还是堆上，这完全由编译器通过“逃逸分析（Escape Analysis）”来决定。

要准确知道一个对象最终分配在哪里，可以通过在编译时加上 -gcflags="-m" 参数来查看编译器的逃逸分析日志。如果日志中显示 escapes to heap，说明分配在堆上；否则，通常分配在栈上。

编译器判断的核心原则是：如果一个变量的生命周期完全在函数内部，它就会被分配在栈上；如果它在函数返回后依然被外部引用（也就是“逃逸”了），或者它占用的内存过大，它就会被分配在堆上。

常见的逃逸场景包括：

指针逃逸：函数返回了局部变量的指针。
动态类型逃逸：将变量作为 interface{} 类型传递（比如调用 fmt.Println）。
栈空间不足：分配的对象太大，超出了栈的容量限制。
闭包引用：闭包内部引用了外部函数的局部变量。

系统讲解

1. 栈与堆的区别

在理解逃逸分析之前，需要明确为什么我们要关心对象分配在哪里：

特性	栈 (Stack)	堆 (Heap)
分配速度	极快（仅需移动栈顶指针）	较慢（需要在堆内存中寻找合适的空闲块）
清理方式	函数返回时自动回收（无需 GC）	依赖垃圾回收器（GC）进行标记和清理
性能影响	无额外开销	会增加 GC 压力，导致程序停顿（STW）或消耗 CPU
容量大小	较小（通常为几 MB）	很大（受限于物理内存）

正因为栈分配的成本极低且不需要 GC，Go 编译器会尽可能地将对象分配在栈上。只有在迫不得已时，才会将其分配到堆上。

2. 逃逸分析 (Escape Analysis)

逃逸分析是 Go 编译器在编译阶段进行的一项代码静态分析。它的主要任务是追踪变量的作用域和生命周期。

基本规则：

向下引用（传递给调用的函数）：通常不会逃逸（除非被调用的函数将其保存到了全局变量或返回了它的指针）。
向上引用（返回给调用者）：一定会逃逸到堆上。

3. 如何验证逃逸分析

我们可以使用 go build -gcflags="-m" 命令来观察编译器的决策过程。-m 表示打印优化决策，如果想看更详细的过程，可以使用 -m -m。

示例代码与分析

package main
 
import "fmt"
 
// 场景 1：不逃逸（分配在栈上）
func noEscape() int {
    x := 10 // x 的生命周期仅在 noEscape 内部
    return x
}
 
// 场景 2：指针逃逸（分配在堆上）
func pointerEscape() *int {
    y := 20 // 返回了 y 的指针，y 的生命周期超出了 pointerEscape 函数
    return &y
}
 
func main() {
    a := noEscape()
    b := pointerEscape()
    
    // 场景 3：动态类型逃逸（分配在堆上）
    // fmt.Println 的参数是 ...interface{}，编译器无法确定其具体类型和生命周期
    fmt.Println(a, *b) 
}

执行逃逸分析命令：

$ go build -gcflags="-m" main.go
# command-line-arguments
./main.go:12:2: moved to heap: y      // y 逃逸到了堆上（指针逃逸）
./main.go:22:13: ... argument does not escape
./main.go:22:13: a escapes to heap    // a 逃逸到了堆上（interface{} 动态类型逃逸）
./main.go:22:16: *b escapes to heap   // *b 逃逸到了堆上（interface{} 动态类型逃逸）

4. 常见的逃逸场景汇总

除了上述的指针逃逸和动态类型逃逸，还有以下几种常见情况会导致对象分配在堆上：

切片/Map/Channel 存储指针：如果在一个切片或 map 中存储了局部变量的指针，该局部变量会逃逸。
```
func sliceEscape() {
    x := 10
    s := make([]*int, 1)
    s[0] = &x // x 逃逸到堆上
}
```
栈空间不足（大对象逃逸）：如果分配的局部变量过大（例如一个非常大的数组），栈空间无法容纳，编译器会将其分配到堆上。
```
func largeObjectEscape() {
    // 通常超过 64KB 的对象会直接分配在堆上
    s := make([]int, 10000, 10000) 
    _ = s
}
```

闭包引用：闭包函数内部引用了外部函数的局部变量，导致该变量的生命周期被延长。

func closureEscape() func() int {
    x := 0 // x 逃逸到堆上，因为它被内部的匿名函数引用并返回了
    return func() int {
        x++
        return x
    }
}

5. 常见追问

追问 1：使用 new 或 make 初始化的对象，一定会分配在堆上吗？

不一定。 Go 语言与 C/C++ 不同，new 和 make 只是用于分配内存和初始化对象的内置函数，它们并不决定内存分配的位置。最终分配在栈上还是堆上，完全取决于逃逸分析的结果。如果通过 new 创建的对象没有逃逸，编译器依然会将其优化并分配在栈上。

追问 2：既然逃逸到堆上会增加 GC 压力，我们在写代码时应该尽量避免使用指针吗？

不能一概而论。 虽然传递值（不使用指针）可以避免逃逸，从而减轻 GC 压力，但如果传递的是一个非常大的结构体，值拷贝的 CPU 开销可能会远大于 GC 的开销。

对于小对象（如几个基础类型字段的结构体），优先传递值。
对于大对象，或者需要修改对象内部状态的情况，依然应该使用指针。
核心原则：不要为了过早优化而牺牲代码的可读性和合理性。只有在性能瓶颈分析（Profiling）明确指向 GC 压力过大时，才需要针对性地优化逃逸现象。

lllllan's blog

探索