📚 课程目录第2章 Go并发模型与Goroutine

2. Go 并发模型与 Goroutine：调度原理、GMP 模型与并发编程基础

在分布式链路追踪系统中，探针需要以极低的开销捕获成千上万个请求的上下文信息。Go 语言的 Goroutine 轻量级并发模型正是实现这一目标的核心基石。本章将深入剖析 Goroutine 的调度原理、GMP 模型结构，并厘清并发与并行的本质区别，最后通过基础并发编程示例，为后续的链路追踪上下文传播打下坚实基础。

2.1 并发与并行的本质区别

并发与并行是分布式系统设计中最容易被混淆的概念。理解它们的区别，对于设计高效的链路追踪代理至关重要。

维度	并发 (Concurrency)	并行 (Parallelism)
核心定义	逻辑上的“同时”处理多个任务（交替执行）	物理上的“同时”执行多个任务（真正同时）
硬件依赖	单核 CPU 即可实现	必须多核 CPU 或多处理器
执行方式	任务时间片轮转，宏观并行，微观串行	任务在不同核心上独立运行
关注点	任务的结构设计（如何分解）	任务的执行效率（如何加速）
Go 中的体现	通过 `go` 关键字创建大量 Goroutine	通过 `GOMAXPROCS` 控制并行度

关键认知： 并发是一种 设计模式，而并行是一种 执行状态。在链路追踪中，我们通过并发设计来管理大量 Span 的创建与上报，而并行则用于在多核机器上加速数据处理。

2.2 Goroutine 调度原理与 GMP 模型

Goroutine 是 Go 运行时调度的基本单位，其调度器经历了从 G-M 模型到 GMP 模型的演进。GMP 模型通过引入逻辑处理器 P，解决了全局锁竞争和线程频繁阻塞的问题，使得 Goroutine 的调度效率提升了数个数量级。

2.2.1 GMP 核心组件

G (Goroutine)：代表一个待执行的任务。包含栈指针、程序计数器、关联的 M 等信息。G 的状态包括：空闲、就绪、运行、阻塞、终止。
M (Machine/Thread)：代表操作系统线程。M 负责执行 G 中的代码。M 的数量受限于操作系统，但通常远少于 G 的数量。
P (Processor)：代表逻辑处理器。P 是 GMP 模型的关键，它持有本地 Goroutine 队列（LRQ）。P 的数量由 GOMAXPROCS 决定，默认等于 CPU 核心数。

  GMP 模型优势： 每个 P 拥有独立的本地队列，减少了全局队列的锁竞争。当 M 阻塞时，P 可以立即绑定另一个 M 继续执行，提高了 CPU 利用率。

2.2.2 调度流程与策略

创建：通过 go func() 创建一个 G，优先放入当前 P 的本地队列（LRQ）。如果 LRQ 已满，则放入全局队列（GRQ）。
获取：P 每执行完一个 G，会按顺序尝试获取下一个 G：本地队列 → 全局队列 → 任务窃取。
任务窃取 (Work Stealing)：当 P 的本地队列为空时，它会从其他 P 的本地队列尾部“偷取”一半的 G，实现负载均衡。
系统调用：当 G 发起系统调用（如文件读写）时，M 会进入阻塞状态。此时 P 会与当前 M 解绑，并绑定一个新的 M（或从休眠队列中唤醒一个 M）继续执行其他 G。
网络轮询：对于网络 I/O，Go 使用网络轮询器（Netpoller）实现异步处理。G 在等待网络数据时会被挂起，数据到达后由轮询器唤醒并重新加入 P 的队列。

性能陷阱： 如果 Goroutine 中存在大量同步系统调用（如频繁加锁、文件 I/O），会导致 M 频繁阻塞和 P 解绑，增加调度开销。在链路追踪中，应优先使用异步 I/O 或无锁数据结构。

2.3 Go 并发编程基础

掌握 Goroutine 和 Channel 是编写并发程序的基础。下面通过一个模拟链路追踪中 Span 处理的示例，展示基本的并发模式。

2.3.1 Goroutine 与 WaitGroup

package main

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

// 模拟处理一个 Span
func processSpan(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 标记任务完成
    fmt.Printf("开始处理 Span %d\n", id)
    time.Sleep(100 * time.Millisecond) // 模拟处理耗时
    fmt.Printf("完成处理 Span %d\n", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1) // 增加计数器
        go processSpan(i, &wg) // 启动 Goroutine
    }
    wg.Wait() // 等待所有 Goroutine 完成
    fmt.Println("所有 Span 处理完毕")
}

2.3.2 Channel 通信与 Select

Channel 是 Goroutine 之间通信的主要方式。在链路追踪中，我们常用 Channel 将采集到的 Span 从生产者传递给消费者（如上报模块）。

package main

import (
    "fmt"
    "time"
)

// Span 数据结构
type Span struct {
    TraceID string
    SpanID  string
    Duration time.Duration
}

// 生产者：模拟生成 Span
func producer(ch chan<- Span) {
    for i := 0; i < 3; i++ {
        span := Span{
            TraceID: fmt.Sprintf("trace-%d", i),
            SpanID:  fmt.Sprintf("span-%d", i),
            Duration: time.Duration(i*100) * time.Millisecond,
        }
        fmt.Printf("生产 Span: %s\n", span.SpanID)
        ch <- span // 发送到 Channel
        time.Sleep(50 * time.Millisecond)
    }
    close(ch) // 关闭 Channel，通知消费者
}

// 消费者：处理 Span
func consumer(ch <-chan Span) {
    for span := range ch { // 从 Channel 接收，直到关闭
        fmt.Printf("消费 Span: %s, 耗时: %v\n", span.SpanID, span.Duration)
    }
}

func main() {
    ch := make(chan Span, 2) // 带缓冲的 Channel
    go producer(ch)
    consumer(ch)
    fmt.Println("处理完成")
}

2.3.3 并发模式对比

模式	适用场景	优点	缺点
WaitGroup	等待一组 Goroutine 全部完成	简单直接，适合批量任务	无法传递结果或错误
Channel	生产者-消费者、流水线	类型安全，天然支持同步	需要管理缓冲和关闭
Select	多路复用、超时控制	灵活处理多个 Channel	逻辑复杂度增加
Mutex	保护共享内存	细粒度控制	容易导致死锁和竞争

2.4 本章小结

并发 ≠ 并行：并发是任务分解的设计，并行是物理执行。Go 通过 Goroutine 实现高并发，通过 GOMAXPROCS 控制并行度。
GMP 模型：通过引入逻辑处理器 P，实现了高效的 Goroutine 调度，支持任务窃取和异步系统调用，是 Go 高并发性能的基石。
调度状态机：Goroutine 在空闲、就绪、运行、阻塞、终止之间流转，理解状态转换有助于诊断性能瓶颈。
基础并发工具：go 关键字、sync.WaitGroup、Channel 和 select 是构建并发程序的四大核心组件。