2. Goroutine 基础：创建、生命周期与轻量级特性

Goroutine 是 Go 语言并发编程的核心执行单元。与操作系统线程不同，Goroutine 由 Go 运行时（Runtime）管理，而非 OS 内核。本章从创建方式、主从协程关系以及轻量级本质三个维度，建立对 Goroutine 的基础认知。

2.1 创建 Goroutine：go 关键字

在 Go 中，只需在函数调用前加上 go 关键字，即可启动一个 Goroutine。该函数可以是命名函数、匿名函数或闭包。

package main

import (
    "fmt"
    "time"
)

func say(msg string) {
    for i := 0; i < 3; i++ {
        fmt.Println(msg)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    // 启动一个 Goroutine 执行 say 函数
    go say("Hello from Goroutine")

    // 主协程继续执行
    say("Hello from Main")

    // 等待子协程有机会执行（仅示例，非生产做法）
    time.Sleep(500 * time.Millisecond)
    fmt.Println("Main exits")
}

2.2 主协程与子协程的关系

每个 Go 程序启动时，main 函数运行在 主 Goroutine 中。由主 Goroutine 通过 go 启动的称为 子 Goroutine。它们之间遵循以下规则：

• 主协程退出即程序终止：当 main 函数返回时，整个进程结束，所有子 Goroutine 无论是否执行完毕，都会被强制终止。
• 子协程无法阻止主协程退出：子 Goroutine 没有“守护”概念，主协程不会等待子协程完成（除非使用 sync.WaitGroup 或 channel 同步）。
• 父子关系非层级：Goroutine 之间没有严格的父子树结构。子 Goroutine 可以继续创建新的 Goroutine，所有 Goroutine 都由全局调度器统一管理。

2.3 Goroutine 的轻量级特性

Goroutine 之所以能支持百万级并发，源于其与 OS 线程的本质差异。下表对比了关键指标：

轻量级的核心原因：

• 用户态调度：Go 运行时实现 M:N 调度模型（M 个 Goroutine 映射到 N 个 OS 线程），切换不涉及系统调用。
• 动态栈：初始栈仅 2 KB，按需增长，内存利用率极高。
• 协作式抢占：Goroutine 在函数调用、channel 操作、系统调用等时机自动让出 CPU，无需内核时钟中断。

2.4 Goroutine 生命周期与状态流转

下图展示了 Goroutine 从创建到退出的核心状态机。理解状态转换是后续学习调度器原理的基础。

状态流转说明：

• Grunnable → Grunning：调度器从本地或全局运行队列中取出 Goroutine，绑定到 P 上执行。
• Grunning → Gwaiting：Goroutine 因 channel 读写、锁等待、time.Sleep 等主动让出 CPU。
• Grunning → Gsyscall：Goroutine 发起阻塞式系统调用（如文件读写、网络 I/O），运行时将 P 与 M 解绑，让其他 Goroutine 继续执行。
• Grunning → Gdead：Goroutine 正常返回或发生不可恢复的 panic。

2.5 实战：验证 Goroutine 的轻量级

以下代码演示了创建 10 万个 Goroutine 的内存开销：

package main

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

func main() {
    var wg sync.WaitGroup
    n := 100000

    // 记录创建前内存
    var m1 runtime.MemStats
    runtime.ReadMemStats(&m1)

    for i := 0; i < n; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            // 模拟轻量工作
            _ = id * id
        }(i)
    }

    wg.Wait()

    // 记录创建后内存
    var m2 runtime.MemStats
    runtime.ReadMemStats(&m2)

    fmt.Printf("创建 %d 个 Goroutine\n", n)
    fmt.Printf("内存增量: %d KB\n", (m2.TotalAlloc-m1.TotalAlloc)/1024)
    fmt.Printf("平均每个 Goroutine: %d bytes\n", (m2.TotalAlloc-m1.TotalAlloc)/uint64(n))
}

对比 OS 线程（每个至少 1 MB 栈），Goroutine 的内存效率高出 500 倍以上。这正是 Go 能支撑高并发网络服务（如 HTTP 网关、消息推送）的底层基础。