1. 前言

1.1 为什么需要关注堆栈分配？

在Go语言中，内存分配主要有两种方式：

• 栈分配：轻量快速，函数结束时自动释放，不产生垃圾
• 堆分配：需要垃圾回收(GC)参与，开销较大

关键区别：

• 栈分配比堆分配快10-100倍
• 栈分配不会增加GC压力
• 堆分配的对象生命周期更长

1.2 什么是逃逸分析？

逃逸分析是Go编译器在编译时进行的一种优化技术，它会分析变量的生命周期和使用方式，自动决定将变量分配在栈上还是堆上。

2. 逃逸分析实战

2.1 如何查看逃逸分析结果

在下面代码中，将x的变量的地址返回出去了，这个时候会将x放到堆上。

func allocate() *int {
	x := 42
	return &x // x escapes to the heap
}

func main() {
	allocate()
}

通过添加参数-gcflags="-m"可以看到如下逃逸的信息

$ go build -gcflags="-m"  main.go
...
./main.go:4:2: moved to heap: x

2.2常见的逃逸场景

1. 返回局部变量指针

func escape() *int {
    x := 10
    return &x // escapes
}

2. 闭包使用局部变量

func closureEscape() func() int {
    x := 5
    return func() int { return x } // x escapes
}

3. 接口类型转换

func toInterface(i int) interface{} {
    return i // escapes if type info needed at runtime
}

4. 全局变量赋值

var global *int

func assignGlobal() {
    x := 7
    global = &x // escapes
}

5. 大尺寸对象

func makeLargeSlice() []int {
    s := make([]int, 10000) // may escape due to size
    return s
}

3. 堆与栈的性能基准测试

type Data struct {
	A, B, C int
}

// 栈分配
func StackAlloc() Data {
    return Data{1, 2, 3} // stays on stack
}

// 堆分配
func HeapAlloc() *Data {
    return &Data{1, 2, 3} // escapes to heap
}

func BenchmarkStackAlloc(b *testing.B) {
    for b.Loop() {
        _ = StackAlloc()
    }
}

func BenchmarkHeapAlloc(b *testing.B) {
    for b.Loop() {
        _ = HeapAlloc()
    }
}

通过运行会发现两者区别并不大，而且竟然没有堆的申请。这是因为编译器很聪明，它发现通过HeapAlloc返回的指针没有任何意义，所以也就把它放在了栈上。

$ go test -bench=. -benchmem .  
goos: darwin
goarch: arm64
pkg: main/demo
cpu: Apple M4 Pro
BenchmarkStackAlloc-12          1000000000               0.2373 ns/op          0 B/op          0 allocs/op
BenchmarkHeapAlloc-12           1000000000               0.2253 ns/op          0 B/op          0 allocs/op
PASS
ok      main/demo       1.176s

我需要强制让它分配到堆上，使用全局赋值，修改代码后如下

type Data struct {
	A, B, C int
}

var sink *Data

func HeapAllocEscape() {
	d := &Data{1, 2, 3}
	sink = d // d escapes to heap
}

func StackAlloc() Data {
	return Data{1, 2, 3} // stays on stack
}

func BenchmarkStackAlloc(b *testing.B) {
	for range b.N {
		_ = StackAlloc()
	}
}

func BenchmarkHeapAlloc(b *testing.B) {
	for range b.N {
		HeapAllocEscape()
	}
}

运行结果如下，使用堆存储的开销：35倍的慢调用，24 字节的分配和 1 次垃圾回收的对象。

$ go test -bench=. -benchmem .  
goos: darwin
goarch: arm64
pkg: main/demo
cpu: Apple M4 Pro
BenchmarkStackAlloc-12          1000000000               0.2285 ns/op          0 B/op          0 allocs/op
BenchmarkHeapAlloc-12           147388731                8.117 ns/op          24 B/op          1 allocs/op
PASS
ok      main/demo       3.064s

4. 最佳实践

4.1 优化栈分配场景

• GC 压力大的时候
• 对于短期的小对象
• 高频调用的函数内部

4.2 不必强求栈分配的场景

• 工厂方法返回对象指针(Go惯用法)
• 对象需要跨函数生命周期。
• 不频繁创建的小对象
• 优化会影响代码可读性时

5. 总结

1. 逃逸分析是Go的重要优化手段，自动决定变量分配位置。
2. 栈分配性能优势明显，适合短生命周期对象。
3. 堆分配虽然较慢，但在某些场景下是必要且合理的。
4. 优化时要平衡性能与代码质量，避免过度优化。