📚 课程目录第1章 Go并发模型基础

1. Go并发模型基础：Goroutine与Channel的核心原理、GMP调度模型图解、并发与并行的区别

1.1 并发与并行的本质区别

在进入Go并发模型之前，必须厘清两个常被混淆的核心概念：并发（Concurrency）与并行（Parallelism）。Go语言的设计哲学强调“通过并发实现并行”，但二者并非同一层次的问题。

维度	并发（Concurrency）	并行（Parallelism）
定义	逻辑上同时处理多个任务（任务交替执行）	物理上同时执行多个任务（真正的同时运行）
关注点	任务的结构设计与分解	任务的执行效率与吞吐
硬件依赖	单核CPU即可实现（时间片轮转）	必须多核CPU或多处理器
Go中的体现	Goroutine的创建与调度	GOMAXPROCS控制的工作线程数
经典比喻	一个人交替吃三碗面	三个人同时各吃一碗面

开发环境避坑提示：在本地开发机上，GOMAXPROCS 默认等于CPU核心数，此时并发程序可能表现出并行行为。但在容器化开发环境（如Docker限制CPU配额）中，GOMAXPROCS 可能读取到宿主机核心数而非容器配额，导致线程数过多、上下文切换加剧。建议在开发容器中使用 uber-go/automaxprocs 库自动适配。

1.2 Goroutine：轻量级执行体

Goroutine是Go并发模型的最小执行单元，由Go运行时管理而非操作系统。与传统线程相比，Goroutine具有以下关键特征：

栈空间极小：初始栈仅2KB，可动态增长至1GB（实际受内存限制）
创建成本低：创建约4KB开销，线程约1MB
切换速度快：Goroutine切换约几十纳秒，线程切换约微秒级
内置通信机制：通过Channel实现CSP（Communicating Sequential Processes）模型

// 启动一个Goroutine
go func() {
    fmt.Println("Hello from goroutine")
}()

// 启动多个Goroutine
for i := 0; i < 10; i++ {
    go func(id int) {
        fmt.Printf("Goroutine %d running\n", id)
    }(i)
}

1.3 Channel：Goroutine之间的通信桥梁

Go遵循“不要通过共享内存来通信，而应通过通信来共享内存”的原则。Channel是Goroutine之间传递消息的管道，分为无缓冲（同步）和有缓冲（异步）两种类型。

特性	无缓冲 Channel	有缓冲 Channel
声明方式	`make(chan int)`	`make(chan int, 10)`
发送行为	发送方阻塞直到接收方就绪	缓冲区未满时发送不阻塞
接收行为	接收方阻塞直到有数据	缓冲区非空时接收不阻塞
典型用途	同步、信号通知、事件触发	任务队列、流量控制、解耦生产消费
关闭后行为	接收已关闭的chan立即返回零值	接收已关闭的chan返回剩余缓冲数据

// 无缓冲Channel：同步通信
ch := make(chan string)
go func() {
    ch <- "ping"  // 发送，阻塞直到接收
}()
msg := <-ch       // 接收，阻塞直到发送
fmt.Println(msg)  // 输出: ping

// 有缓冲Channel：异步通信
bufCh := make(chan int, 3)
bufCh <- 1
bufCh <- 2
bufCh <- 3       // 缓冲区满前不阻塞
// bufCh <- 4    // 缓冲区满，阻塞
fmt.Println(<-bufCh) // 输出: 1

开发环境常见故障：Channel未关闭导致Goroutine泄漏。在开发调试阶段，如果Goroutine在读取Channel时未检测关闭状态，且发送方已退出，接收方将永久阻塞。务必使用 for v := range ch 或 v, ok := <-ch 模式处理关闭信号。

1.4 GMP调度模型图解

Go运行时调度器采用GMP模型，实现了用户态Goroutine到内核线程的高效映射。理解GMP是排查并发性能问题和死锁故障的基础。

  GMP核心组件：
  G（Goroutine）：轻量级协程，包含栈、PC、上下文等
M（Machine）：操作系统线程，由Go运行时管理
P（Processor）：逻辑处理器，负责调度G到M上执行

1.5 GMP调度流程详解

GMP调度器的工作流程可以概括为以下关键步骤，理解这些步骤对于排查开发环境中的调度延迟和死锁问题至关重要：

G创建：通过 go func() 创建G，初始放入当前P的本地队列（LRQ）
本地队列满：当P的本地队列长度超过256时，将一半G移入全局队列（GRQ）
P获取G：P优先从本地队列获取G；本地队列为空时，从全局队列获取（加锁）
工作窃取（Work Stealing）：当P的本地队列和全局队列都为空时，随机窃取其他P本地队列的一半G
系统调用阻塞：G发生阻塞系统调用时，P与M解绑，P寻找新的M继续执行其他G
G返回：阻塞结束后，G进入全局队列等待重新调度

开发环境调试命令：

// 查看当前Goroutine数量
runtime.NumGoroutine()

// 设置最大P数量
runtime.GOMAXPROCS(n)

// 查看调度器状态（需要导入runtime/pprof）
import _ "net/http/pprof"
// 访问 /debug/pprof/goroutine 查看Goroutine堆栈

1.6 Channel与Goroutine的协作模式

在实际开发中，Goroutine与Channel的组合形成了多种经典并发模式。以下是开发环境中最常用的三种模式：

模式	结构	适用场景	故障风险
生产者-消费者	多个Goroutine写入Channel，多个Goroutine读取	任务队列、日志处理、数据流水线	Channel未关闭导致Goroutine泄漏
扇出（Fan-Out）	一个Channel分发到多个Goroutine处理	并行计算、负载均衡	Channel关闭后继续发送导致panic
扇入（Fan-In）	多个Channel合并到一个Channel	结果汇总、多源数据聚合	select语句未处理所有Channel导致饥饿

// 生产者-消费者模式示例
func producer(ch chan<- int, count int) {
    for i := 0; i < count; i++ {
        ch <- i
    }
    close(ch) // 必须关闭，否则消费者死锁
}

func consumer(ch <-chan int, id int) {
    for v := range ch { // 自动检测关闭
        fmt.Printf("Consumer %d received: %d\n", id, v)
    }
}

func main() {
    ch := make(chan int, 10)
    go producer(ch, 5)
    go consumer(ch, 1)
    go consumer(ch, 2)
    time.Sleep(time.Second) // 等待完成
}

开发环境死锁排查：当所有Goroutine都处于阻塞状态且没有Goroutine能够解除阻塞时，Go运行时会检测到死锁并panic。常见原因包括：Channel未关闭导致range循环永久阻塞、所有Goroutine都在等待Channel发送/接收、互斥锁未释放。使用 go run -race 可以检测数据竞争，使用 pprof 可以查看Goroutine阻塞状态。

select 语句处理多Channel，避免Goroutine饥饿

1.7 开发环境常见故障与排查思路

在Development环境中，由于资源限制和调试工具不完善，Goroutine和Channel相关故障尤为常见。以下是三类高频问题及其排查方法：

故障类型	现象	根因	排查命令/工具
Goroutine泄漏	程序内存持续增长，响应变慢	Channel未关闭、死循环、阻塞未超时	`pprof/goroutine`、`runtime.NumGoroutine()`
死锁	程序卡死，无响应	所有Goroutine阻塞等待，无解除条件	Go运行时自动检测并panic，`GOTRACEBACK=all`
数据竞争	偶发panic、结果不一致	多个Goroutine同时读写同一变量	`go run -race`、`go test -race`

开发环境最佳实践：

始终使用 go run -race 运行开发中的代码
为Channel操作设置超时：select { case <-ch: ... case <-time.After(5s): ... }
使用 sync.WaitGroup 等待Goroutine完成，避免主Goroutine提前退出
在Docker开发容器中显式设置 GOMAXPROCS 为容器CPU配额