Go栈与堆的区别详解

理解栈和堆的分配机制是优化内存性能的基础。

栈vs堆对比

栈分配机制

Goroutine栈

// 每个goroutine有自己的栈
// 初始大小：2KB
// 最大限制：1GB（64位系统）

// 栈增长：动态扩容
// 当栈空间不足时，自动扩容（翻倍）

栈分配过程

func add(a, b int) int {
    var result int  // 栈分配
    result = a + b
    return result   // 值拷贝返回
}

// 编译时确定栈布局
// 返回时栈指针移动，无分配成本

栈扩容

func deepCall(n int) {
    if n <= 0 {
        return
    }
    var buf [1024]byte  // 使用栈空间
    deepCall(n - 1)     // 递归可能触发扩容
}

// 栈扩容流程：
// 1. 检测栈空间不足
// 2. 分配新栈（2倍大小）
// 3. 复制旧栈数据
// 4. 调整指针
// 5. 继续执行

堆分配机制

堆分配触发条件

// 1. 返回指针（逃逸）
func create() *int {
    x := 42
    return &x  // x逃逸到堆
}

// 2. 闭包引用（逃逸）
func closure() func() {
    x := 42
    return func() {
        fmt.Println(x)  // x逃逸
    }
}

// 3. 大对象
func bigData() {
    buf := make([]byte, 10000)  // 大对象堆分配
}

// 4. 动态大小
func dynamic(n int) {
    buf := make([]byte, n)  // 大小不确定，堆分配
}

堆分配流程

func heapAlloc() {
    x := new(int)  // 堆分配

    // 流程：
    // 1. mallocgc(size)
    // 2. 确定size class
    // 3. mcache → mcentral → mheap
    // 4. 返回指针
}

逃逸分析决定分配位置

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

# 输出示例
main.go:5:6: can inline add
main.go:10:6: &x escapes to heap
main.go:10:6: moved to heap: x

不逃逸示例

func local() {
    var x int = 42  // 栈分配
    y := x + 1      // 栈分配
    fmt.Println(y)
    // 函数返回，栈自动释放
}

逃逸示例

func escape() *int {
    var x int = 42
    return &x  // x逃逸，堆分配
}

// 原因：
// x被返回到函数外部
// 函数返回后x仍需存在
// 无法在栈上（栈随函数返回释放）

性能影响对比

栈分配开销

func BenchmarkStack(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var x int = 42  // 栈分配，几乎零成本
        _ = x
    }
}
// 结果：~0.3ns/op

堆分配开销

func BenchmarkHeap(b *testing.B) {
    for i := 0; i < b.N; i++ {
        x := new(int)   // 堆分配
        *x = 42
        _ = x
    }
}
// 结果：~50ns/op（含GC压力）

堆分配比栈分配慢约100-1000倍。

GC压力

// 栈分配：无GC压力
func stackLoop() {
    for i := 0; i < 1000000; i++ {
        var x int  // 栈分配，函数结束自动释放
        _ = x
    }
}

// 堆分配：增加GC压力
func heapLoop() {
    for i := 0; i < 1000000; i++ {
        x := new(int)  // 堆分配，GC需要回收
        _ = x
    }
}

优化原则

优先栈分配

// 不推荐：指针返回导致逃逸
func create() *User {
    return &User{Name: "Tom"}
}

// 推荐：值返回，栈分配
func create() User {
    return User{Name: "Tom"}
}

控制对象大小

// 小对象可能栈分配
type Small struct {
    a, b int  // 16字节
}

// 大对象必然堆分配
type Large struct {
    data [10000]byte  // 10KB
}

避免不必要的逃逸

// 逃逸：接口装箱
func printAny(v interface{}) {
    fmt.Println(v)
}
printAny(42)  // 42逃逸

// 不逃逸：具体类型
func printInt(v int) {
    fmt.Println(v)
}
printInt(42)  // 42不逃逸

要点总结

• 栈分配快零成本，堆分配慢有GC压力
• 栈随函数返回自动释放，堆需GC回收
• 逃逸分析决定栈或堆分配
• 返回指针、闭包引用、大对象会逃逸
• 用go build -gcflags="-m"查看逃逸
• 优先值返回减少逃逸
• 小对象栈分配性能最优