Golang 内存管理深度解析：栈与堆、GC 三色标记与 defer 底层

// 不逃逸：返回结构体本身
type User struct {
    Name string
}

func createUserOnStack() User {
    u := User{Name: "Alice"}  // 栈上分配
    return u
}

// 逃逸：返回指针
func createUserOnHeap() *User {
    u := &User{Name: "Alice"} // 堆上分配
    return u
}

// 1. 返回局部变量的指针
func escape1() *int {
    x := 42
    return &x  // x 逃逸到堆
}

// 2. 变量存储在接口中（interface{}）
func escape2() interface{} {
    x := 42
    return x   // 具体类型 -> 接口装箱，逃逸
}

// 3. 闭包捕获变量
func escape3() func() int {
    x := 42
    return func() int {
        x++    // x 被闭包捕获，逃逸到堆
        return x
    }
}

// 4. 变量大小不确定
func escape4(n int) []int {
    s := make([]int, n)  // 编译时大小未知
    return s             // 必定逃逸
}

$ go build -gcflags='-m' main.go
./main.go:10:6: can inline createUserOnStack
./main.go:17:9: &User{...} escapes to heap
./main.go:21:6: moved to heap: u

flowchart TD
    A[函数执行] --> B[变量声明]
    B --> C{生命周期超出函数?}
    C -->|否| D[栈上分配]
    C -->|是| E[堆上分配]
    C -->|不确定| F[保守策略: 堆上分配]
    D --> G[函数返回时自动回收]
    E --> H[GC 追踪回收]

// 三色标记的简化实现
func triColorMark(root *Object) {
    var whiteSet []*Object
    var grayQueue []*Object

    // 初始化：根对象标记为灰色
    grayQueue = append(grayQueue, root)

    for len(grayQueue) > 0 {
        // 弹出灰色对象
        obj := grayQueue[0]
        grayQueue = grayQueue[1:]

        // 扫描灰色对象的引用
        for _, ref := range obj.References() {
            if isWhite(ref) {
                // 白色 -> 灰色
                grayQueue = append(grayQueue, ref)
            }
        }

        // 当前对象变为黑色
        markBlack(obj)
    }

    // 剩余白色对象为垃圾
    sweep(whiteSet)
}

// 伪代码：赋值前触发
func writePointerWithBarrier(slot *Object, newPtr *Object) {
    if isConcurrentGC() {
        // 如果新引用的对象是白色的，标记为灰色
        if isWhite(newPtr) {
            markGrey(newPtr)
        }
    }
    *slot = newPtr
}

// 伪代码：赋值时触发
func writePointerWithDeletionBarrier(slot *Object, newPtr *Object) {
    oldPtr := *slot
    if isConcurrentGC() && isGreyOrBlack(slot) {
        // 被删除的旧引用如果是白色也标记为灰色
        if isWhite(oldPtr) {
            markGrey(oldPtr)
        }
    }
    *slot = newPtr
}

整体流程：
1. GC 开始时：短暂 STW，开启写屏障
2. 并发标记：所有 goroutine 一起工作
3. 标记终止：再次 STW，关闭写屏障
4. 并发清扫：回收白色对象

flowchart TD
    subgraph "GC 周期"
        S[GC 触发条件] --> P1[GC STW 开启]
        P1 --> M[并发标记阶段]
        M --> P2[标记终止 STW]
        P2 --> SW[并发清扫]
        SW --> E[等待下次触发]
    end

    subgraph "触发条件"
        T1[堆内存增长到阈值]
        T2[手动 runtime.GC]
        T3[超过 2 分钟未 GC]
    end

    T1 --> S
    T2 --> S
    T3 --> S

// runtime/runtime2.go
type _defer struct {
    siz       int32       // 参数和结果的总大小
    started   bool        // 是否已经开始执行
    heap      bool        // 是否在堆上分配
    openDefer bool        // 是否开启优化
    sp        uintptr     // 栈指针（用于判断作用域）
    pc        uintptr     // 返回地址
    fn        funcData    // 被 deferred 的函数
    _panic    *_panic     // 关联的 panic
    link      *_defer     // 链表指针
}

func deferOrder() {
    defer fmt.Println("1") // 第三个执行
    defer fmt.Println("2") // 第二个执行
    defer fmt.Println("3") // 第一个执行
    // 输出: 3 2 1
}

// runtime/runtime2.go
type _panic struct {
    argp      unsafe.Pointer
    arg       interface{}    // panic 的参数
    link      *_panic        // 链表（支持嵌套 panic）
    recovered bool           // 是否已被 recover
    aborted   bool           // 是否被终止
    pc        uintptr
    sp        uintptr
}

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()

    fmt.Println("Start")
    panic("something went wrong")
    fmt.Println("End") // 不会执行
}
// 输出: Start
//      Recovered: something went wrong

sequenceDiagram
    participant F as 函数
    participant D as defer 链表
    participant P as _panic 链表
    participant R as recover

    F->>P: panic("err") 
    P->>D: 遍历 defer 链表
    D->>D: 从链头取出 defer 执行
    D->>R: defer 中包含 recover
    R->>P: 标记 recovered=true
    R->>F: 返回当前函数执行权
    Note over F: 当前函数继续正常返回

func nestedPanic() {
    defer func() {
        fmt.Println("First defer")
        // recover 最内层的 panic
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()

    defer func() {
        panic("inner panic") // 第二个 defer 中 panic
    }()

    panic("outer panic")
}
// 输出:
// First defer
// Recovered: inner panic

func invalidRecover() {
    defer func() {
        func() {
            r := recover()  // 无效！不在直接 defer 的函数中
            fmt.Println(r)  // nil
        }()
    }()
    panic("test")
}

// 未优化：32 字节
type BadStruct struct {
    a bool   // 1 byte + 7 padding
    b int64  // 8 bytes
    c bool   // 1 byte + 7 padding
}

// 优化后：24 字节
type GoodStruct struct {
    b int64  // 8 bytes
    a bool   // 1 byte
    c bool   // 1 byte + 6 padding
}

// ❌ 伪共享问题
type Counter struct {
    a int64  // 8 bytes
    _        [56]byte  // padding 到 64 字节
    b int64  // 不同缓存行（8+56 = 64，b 跨到下一行）
}

// ✅ 实际使用
type PaddingCounter struct {
    a int64
    _ [56]byte  // 隔离缓存行
    b int64
}