2. Goroutine 生命周期：创建、启动、阻塞、退出与泄漏场景

Goroutine 是 Go 并发模型的核心执行单元，其生命周期管理直接决定了程序的稳定性与资源利用率。本章深入剖析 Goroutine 从创建到退出的完整路径，并重点分析导致 Goroutine 泄漏的常见陷阱。

2.1 Goroutine 生命周期全景

一个 Goroutine 的生命周期包含四个核心阶段：创建、启动、阻塞与退出。理解每个阶段的内部机制与资源状态，是构建高可靠并发系统的基础。

2.2 创建与启动：go 语句的幕后

使用 go 关键字启动一个函数调用时，Go 运行时会执行以下步骤：

1. 栈分配： 从堆上分配初始大小为 2KB 的栈空间（Go 1.4+ 实现连续栈）。
2. Goroutine 结构体初始化： 填充 g 结构体，包括栈指针、程序计数器（PC）、函数参数等。
3. 放入运行队列： 将 Goroutine 放入当前 P（Processor）的本地运行队列（LRQ）尾部；若本地队列满，则放入全局运行队列（GRQ）。
4. 调度触发： 当 P 通过调度循环（schedule()）获取到该 Goroutine 时，将其绑定到 M（系统线程）上开始执行。

2.3 阻塞场景与调度策略

Goroutine 阻塞是生命周期中的关键转折点，直接影响系统吞吐量。下表总结了常见的阻塞类型及其调度行为：

2.4 退出机制与资源回收

Goroutine 退出时，Go 运行时会执行以下清理流程：

• defer 函数执行： 按 LIFO 顺序执行所有注册的 defer 调用。
• 栈内存回收： 将 Goroutine 的栈空间标记为可回收，由 GC 后续清理。
• Goroutine 结构体重用： 死亡的 g 结构体被放入空闲列表（sched.gFree），供新 Goroutine 复用，减少内存分配。
• 主 Goroutine 等待： 若主 Goroutine 退出，所有其他 Goroutine 会被强制终止（无论是否执行完毕）。

// 示例：Goroutine 退出与主 Goroutine 等待
package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 退出前通知 WaitGroup
    fmt.Printf("Worker %d 开始\n", id)
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("Worker %d 结束\n", id)
    // 函数返回时，Goroutine 自动退出
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }
    wg.Wait() // 主 Goroutine 阻塞，等待所有 worker 退出
    fmt.Println("所有 worker 已完成")
}

2.5 Goroutine 泄漏的常见场景

Goroutine 泄漏是指 Goroutine 在完成任务后未能正常退出，持续占用栈内存和调度资源，最终导致内存耗尽或性能下降。以下是生产环境中最常见的泄漏场景：

2.5.1 Channel 未关闭导致永久阻塞

这是最常见的泄漏模式。当 Goroutine 在无缓冲 channel 上发送或接收，而另一端没有对应的接收者或发送者时，Goroutine 会永久阻塞。

// 泄漏示例：channel 未关闭导致 Goroutine 永久阻塞
func leakyChannel() {
    ch := make(chan int)
    go func() {
        val := <-ch // 永远没有数据发送过来，Goroutine 永久阻塞
        fmt.Println(val)
    }()
    // 主函数退出，子 Goroutine 泄漏
}

// 正确做法：使用带缓冲 channel 或确保关闭
func safeChannel() {
    ch := make(chan int, 1) // 缓冲为 1，发送不阻塞
    ch <- 42
    go func() {
        val := <-ch
        fmt.Println(val)
    }()
}

2.5.2 select 无 default 且所有 case 阻塞

当 select 语句中所有 channel 操作都不可用，且没有 default 分支时，Goroutine 会永久阻塞。

// 泄漏示例：select 无 default
func leakySelect() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go func() {
        select {
        case <-ch1:
        case <-ch2:
        // 没有 default，两个 channel 都无数据，永久阻塞
        }
    }()
}

// 修复：添加 default 分支或超时
func safeSelect() {
    ch1 := make(chan int)
    go func() {
        select {
        case <-ch1:
        case <-time.After(1 * time.Second): // 超时退出
            fmt.Println("超时退出")
        }
    }()
}

2.5.3 互斥锁未正确释放

当 Goroutine 获取锁后，在释放锁之前发生 panic 或提前返回，导致锁永远无法释放，其他等待该锁的 Goroutine 全部阻塞。

// 泄漏示例：锁未释放
var mu sync.Mutex

func leakyLock() {
    mu.Lock()
    defer mu.Unlock() // 忘记 defer，或 panic 前未解锁
    // 如果这里 panic，锁永远不会释放
    panic("something wrong")
}

// 正确做法：始终使用 defer 解锁
func safeLock() {
    mu.Lock()
    defer mu.Unlock()
    // 即使 panic，defer 也会执行解锁
}

2.5.4 for 循环中启动的 Goroutine 未退出

在 for 循环中启动大量 Goroutine，但循环没有退出条件，或 Goroutine 内部没有检测退出信号，导致 Goroutine 数量持续增长。

// 泄漏示例：for 循环无限启动 Goroutine
func leakyForLoop() {
    for {
        go func() {
            // 这个 Goroutine 永远不会退出
            for {
                time.Sleep(1 * time.Second)
            }
        }()
        time.Sleep(10 * time.Millisecond)
    }
}

// 正确做法：使用 context 控制退出
func safeForLoop(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            return
        default:
            go func() {
                // 执行任务
            }()
        }
    }
}

2.6 生命周期管理最佳实践