2. Go并发基础回顾：goroutine的创建与生命周期、go关键字、runtime.Gosched与runtime.Goexit

在深入容器化并发规划之前，必须牢固掌握Go语言最核心的并发原语——goroutine。本章将系统回顾goroutine的创建机制、生命周期管理，以及两个关键的运行时控制函数：runtime.Gosched与runtime.Goexit。这些基础概念是后续理解调度器、性能建模与容器化部署的基石。

2.1 goroutine：轻量级并发执行体

goroutine是Go运行时管理的用户态线程，其栈空间初始仅2KB，可动态伸缩至1GB。相比操作系统线程（默认栈1MB），goroutine的创建与切换开销低2~3个数量级，这使得Go程序能够轻松创建数十万甚至百万级并发任务。

2.2 go关键字：创建goroutine的唯一入口

在Go中，go关键字是启动一个goroutine的唯一语法。它作用于任意函数或闭包，将其提交给Go运行时调度器，立即返回而不等待函数执行完毕。

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Printf("goroutine: %d\n", i)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    // 使用go关键字启动goroutine
    go printNumbers()

    // 主goroutine继续执行
    for i := 1; i <= 3; i++ {
        fmt.Printf("main: %d\n", i)
        time.Sleep(200 * time.Millisecond)
    }

    // 等待子goroutine完成（实际生产应使用sync.WaitGroup）
    time.Sleep(1 * time.Second)
    fmt.Println("main exit")
}

2.3 goroutine的生命周期模型

每个goroutine从创建到销毁经历四个阶段：创建 → 就绪 → 运行 → 终止。调度器在M（操作系统线程）与P（逻辑处理器）之间调度G（goroutine），实现用户态协作式调度。

2.4 runtime.Gosched：主动让出执行权

runtime.Gosched()使当前goroutine主动放弃CPU执行权，从运行状态切换到就绪状态，让调度器选择其他可运行的goroutine执行。它不会阻塞当前goroutine，只是暂时让出时间片。

package main

import (
    "fmt"
    "runtime"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        defer wg.Done()
        for i := 0; i < 5; i++ {
            fmt.Println("G1:", i)
            // 主动让出CPU，给G2执行机会
            runtime.Gosched()
        }
    }()

    go func() {
        defer wg.Done()
        for i := 0; i < 5; i++ {
            fmt.Println("G2:", i)
            runtime.Gosched()
        }
    }()

    wg.Wait()
}

2.5 runtime.Goexit：优雅终止当前goroutine

runtime.Goexit()立即终止当前goroutine的执行，但在终止前会执行所有已注册的defer函数。它不会影响其他goroutine，也不会导致程序退出。

package main

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

func worker(id int, shouldExit bool) {
    defer fmt.Printf("Worker %d: defer executed\n", id)

    fmt.Printf("Worker %d: started\n", id)

    if shouldExit {
        fmt.Printf("Worker %d: calling Goexit\n", id)
        runtime.Goexit() // 终止当前goroutine，但执行defer
    }

    // 以下代码不会执行
    fmt.Printf("Worker %d: completed normally\n", id)
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        defer wg.Done()
        worker(1, false) // 正常完成
    }()

    go func() {
        defer wg.Done()
        worker(2, true) // 调用Goexit
    }()

    wg.Wait()
    fmt.Println("Main: all goroutines finished")
    time.Sleep(100 * time.Millisecond)
}

2.6 生命周期控制对比总结

2.7 容器化环境下的goroutine生命周期考量

在容器化部署场景中，goroutine的生命周期管理需要额外关注：

• 资源限制： 容器通过cgroups限制CPU和内存，Go运行时自动感知GOMAXPROCS（Go 1.5+默认等于CPU核数），但在容器中可能误判。建议显式设置GOMAXPROCS或使用uber-go/automaxprocs库。
• 优雅关闭： 容器收到SIGTERM信号后，主goroutine应通过context.Context通知所有子goroutine退出，而非依赖runtime.Goexit()。
• goroutine泄漏： 容器长期运行中，未正确退出的goroutine会累积内存和栈空间，最终导致OOM Kill。必须确保每个goroutine都有明确的退出路径。