Lesson 1.1: Go 内存管理与分配

学习目标

• 理解 Go 的内存模型：栈（Stack）与堆（Heap）的区别
• 掌握逃逸分析（Escape Analysis）的原理与影响
• 了解 Go 内存分配器（mcache / mspan）的工作机制
• 能够通过代码优化减少堆分配，提升性能

---

1. 栈 vs 堆

栈（Stack）

栈是每个 Goroutine 私有的连续内存块，默认大小从 Go 1.4 的 4KB 起步，可按需增长（上限 1GB）。

栈上分配的特点：

• 分配/释放开销极低（仅移动栈顶指针）
• 无需 GC 参与
• 函数返回时自动释放
• 适合小对象、生命周期明确的变量

堆（Heap）

堆是全局共享的内存区域，由 Go 的 GC 管理。

堆上分配的特点：

• 分配开销较大（需要锁、空闲列表查找）
• 需要 GC 追踪和回收
• 适合需要在函数间共享、生命周期不确定的对象

// 栈上分配：变量生命周期与函数绑定
func stackAlloc() int {
    x := 42      // x 在栈上分配
    return x
}

// 堆上分配：变量被外部引用
func heapAlloc() *int {
    x := 42      // x 逃逸到堆上
    return &x
}

---

2. 逃逸分析（Escape Analysis）

Go 编译器在编译时进行逃逸分析，决定变量分配在栈还是堆上。逃逸分析的目标是：尽可能将变量分配在栈上。

常见的逃逸场景

场景	说明	示例
返回指针	变量被函数返回引用	return &x
接口存储	将具体类型存入 interface{}	fmt.Println(x)
闭包捕获	闭包引用了外部变量	匿名函数引用外层变量
大对象	过大的栈上分配（>64KB）	make([]int, 100000)
全局变量	全局/包级变量	var g *int

// 使用 go build -gcflags="-m" 查看逃逸分析结果
func escapeExamples() {
    // 情况1: 返回指针 → 逃逸
    p := new(int)  // new(int) escapes to heap
    *p = 42

    // 情况2: interface{} → 逃逸
    var i interface{} = 42  // 42 escapes to heap

    // 情况3: 闭包 → 逃逸
    var count int
    increment := func() { count++ }  // count escapes to heap
    increment()
}

💡 技巧：始终用 -gcflags="-m" 检查逃逸情况，这应该是性能优化的第一步而非最后一步。

---

3. Go 内存分配器

Go 使用基于 tcmalloc 思想的内存分配器，核心结构：

                  +------------+
                  |   mheap    |  ← 全局堆（从 OS 申请大块内存）
                  +------------+
                        ↕
                  +------------+
                  |  mcentral  |  ← 每个 size class 的中心缓存
                  +------------+
                   ↕        ↕
             +---------+  +---------+
             | mcache  |  | mcache  |  ← 每个 P（处理器）私有的缓存
             | (P 0)   |  | (P 1)   |
             +---------+  +---------+

分配路径

1. 微对象 (<16B) → 直接从 mcache 的 tiny allocator 分配
2. 小对象 (16B~32KB) → 从 mcache 的对应 size class 分配（无锁）
3. 大对象 (>32KB) → 直接从 mheap 分配（需全局锁）

// Go 的 size class 示例（共 ~67 种）
// size class  大小(bytes)  对象数/span
// 1            8            512
// 2            16           256
// 3            32           128
// ...          ...          ...
// 64           28672        2
// 65           32768        1
//
// 每个 mspan 管理相同 size class 的对象

---

4. 性能优化实践

减少堆分配

// ❌ 每次调用都分配：
func formatBad(name string) string {
    return fmt.Sprintf("Hello, %s", name)  // 逃逸到堆
}

// ✅ 复用缓冲区：
var buf bytes.Buffer
func formatGood(name string) string {
    buf.Reset()
    buf.WriteString("Hello, ")
    buf.WriteString(name)
    return buf.String()  // 减少内存分配
}

对象复用

// 使用 sync.Pool 复用临时对象
var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 0, 4096)
    },
}

func processRequest() {
    buf := bufferPool.Get().([]byte)
    // 使用 buf...
    bufferPool.Put(buf[:0])  // 重置并归还
}

避免不必要的指针

// ❌ 使用指针（堆分配）
type Config struct {
    Name *string
    Port *int
}

// ✅ 使用值类型（栈分配）
type Config struct {
    Name string
    Port int
    Valid bool  // 用布尔标记零值有效性
}

---

5. 关键工具

工具	命令	用途
逃逸分析	go build -gcflags="-m"	查看变量是否逃逸
内存剖析	go test -bench=. -benchmem	基准测试 + 内存统计
pprof	go tool pprof	内存分配分析
trace	go tool trace	分配事件追踪

---

练习

1. 写一个函数，返回 []byte 类型，用 go build -gcflags="-m" 检查逃逸情况。然后改为通过参数传入缓冲区的方式避免逃逸，对比两者的性能差异（用 benchmark 测试）。

2. 分析以下代码的逃逸行为：

type User struct {
    ID   int
    Name string
}

func NewUser(id int, name string) *User {
    return &User{ID: id, Name: name}
}

func main() {
    u := NewUser(1, "Alice")
    fmt.Println(u.Name)
}

用 -gcflags="-m" 验证你的判断。

3. 阅读 深入理解 Go 内存分配 了解更多细节。