366 lines
12 KiB
Markdown
366 lines
12 KiB
Markdown
# 第五章：并发编程 —— 让程序“多任务”并行
|
||
|
||
> **👋 回顾一下：**
|
||
>
|
||
> 前四章，我们学会了基础语法、数据结构、函数和接口。现在，你已经能写出逻辑清晰、结构良好的代码了。
|
||
>
|
||
> **🤔 但是，现实世界的任务往往很复杂……**
|
||
>
|
||
> 想象一下，你是一家餐厅的老板。
|
||
> * 如果只有一个厨师（单线程），客人点菜 -> 厨师炒菜 -> 上菜。客人要等很久。
|
||
> * 如果有十个厨师（多线程/多协程），可以**同时**处理十张订单，效率翻倍！
|
||
>
|
||
> 这就是**并发 (Concurrency)** 的魅力：**宏观上同时处理多个任务**（微观上可能是交替执行，也可能是真正的并行）。
|
||
>
|
||
> Go 语言天生就是为并发而生的！它提供了**Goroutine**（轻量级线程）和**Channel**（通信管道），让并发编程变得像写串行代码一样简单。
|
||
>
|
||
> **🎯 这一章，我们要掌握 Go 并发的核心：**
|
||
> 1. **Goroutine**：如何启动“小助手”？
|
||
> 2. **GMP 模型**：Go 是怎么调度的？（核心难点，有图解！）
|
||
> 3. **Channel**：Goroutine 之间怎么“传纸条”？
|
||
> 4. **同步原语**：Mutex、WaitGroup、Once（怎么避免“打架”？）。
|
||
> 5. **Context**：怎么统一“叫停”所有任务？
|
||
>
|
||
> **别担心，我会用大量的图解和生活类比，带你轻松攻克这个“高难度”章节！**
|
||
|
||
---
|
||
|
||
## 5.1 Goroutine —— 启动你的“小助手”
|
||
|
||
> **💡 想象一下：**
|
||
> 你有一个大任务（比如处理 1000 个订单）。如果一个个处理，太慢了。
|
||
> 于是，你雇佣了 1000 个**小助手**（Goroutine），每人处理一个订单。
|
||
>
|
||
> 在 Go 中，启动一个小助手只需要一个关键字：**`go`**。
|
||
|
||
### 📝 启动 Goroutine
|
||
|
||
```go
|
||
func sayHello(name string) {
|
||
fmt.Println("你好，", name)
|
||
}
|
||
|
||
func main() {
|
||
go sayHello("Alice") // 启动一个小助手
|
||
go sayHello("Bob")
|
||
go sayHello("Charlie")
|
||
|
||
// 主函数如果退出，所有小助手都会消失！
|
||
// 所以需要等待（后面会讲 WaitGroup）
|
||
time.Sleep(1 * time.Second)
|
||
}
|
||
```
|
||
|
||
> **💡 老师的小揭秘：**
|
||
> * **轻量级**：一个 Goroutine 只占 2KB 内存（操作系统线程要 1-8MB）。
|
||
> * **数量巨大**：可以轻松创建**百万级** Goroutine。
|
||
> * **非阻塞**：`go` 启动后，主程序**立刻继续执行**，不会等待小助手完成。
|
||
|
||
> **⚠️ 老师的小提醒：**
|
||
> * 主函数 `main` 退出，所有 Goroutine 都会**强制终止**。
|
||
> * 所以，如果需要等待 Goroutine 完成，必须用**同步机制**（如 `time.Sleep`、`WaitGroup`、`Channel`）。
|
||
|
||
> **🎮 动手练一练：**
|
||
> 写一个程序，启动 5 个 Goroutine，每个打印“我是第 X 个助手”。观察输出顺序（是不是每次都不一样？）。
|
||
|
||
---
|
||
|
||
## 5.2 GMP 模型 —— Go 的“调度魔法” ⭐ 核心重点
|
||
|
||
> **🤔 为什么 Go 这么快？**
|
||
> 因为 Go 的调度器（Scheduler）非常聪明！它不像操作系统那样直接调度线程，而是自己管理**Goroutine**，把任务分配给**操作系统线程**。
|
||
>
|
||
> 这就是著名的 **GMP 模型**。
|
||
|
||
### 📖 GMP 模型架构（图解）
|
||
|
||
```mermaid
|
||
graph TB
|
||
subgraph "Go Runtime (用户态调度)"
|
||
P1[P1: 逻辑处理器]
|
||
P2[P2: 逻辑处理器]
|
||
Q1[本地 G 队列 Local]
|
||
Q2[本地 G 队列 Local]
|
||
P1 --- Q1
|
||
P2 --- Q2
|
||
GlobalQ[全局 G 队列 Global]
|
||
GlobalQ -.->|偶尔调度 | P1
|
||
GlobalQ -.->|偶尔调度 | P2
|
||
end
|
||
|
||
subgraph "操作系统内核 (Kernel)"
|
||
M1[M1: 线程]
|
||
M2[M2: 线程]
|
||
M1 <-->|绑定 | P1
|
||
M2 <-->|绑定 | P2
|
||
end
|
||
|
||
subgraph "Goroutine 实体"
|
||
G1[G1: 协程]
|
||
G2[G2: 协程]
|
||
G3[G3: 协程]
|
||
G1 --> Q1
|
||
G2 --> Q1
|
||
G3 --> GlobalQ
|
||
end
|
||
|
||
style P1 fill:#ffeb3b,stroke:#333,stroke-width:2px
|
||
style M1 fill:#2196f3,stroke:#333,stroke-width:2px,color:#fff
|
||
style G1 fill:#4caf50,stroke:#333,stroke-width:2px,color:#fff
|
||
style GlobalQ fill:#ff9800,stroke:#333
|
||
```
|
||
|
||
> **📖 深度解析（老师划重点）：**
|
||
> 1. **G (Goroutine)**：绿色节点。
|
||
> * **结构**：包含栈（2KB 起步）、指令指针、状态。
|
||
> * **轻量**：创建开销极小，可创建百万级。
|
||
> * **位置**：被放入 P 的本地队列或全局队列。
|
||
> 2. **P (Processor)**：黄色节点。
|
||
> * **作用**：**调度器**的核心，管理 G 队列，提供执行环境（如内存分配器）。
|
||
> * **数量**：等于 `GOMAXPROCS`（通常=CPU 核数）。**P 的数量限制了最大并行度**。
|
||
> * **本地队列**：每个 P 维护一个本地队列（最多 256 个 G），优先调度，减少锁竞争。
|
||
> 3. **M (Machine)**：蓝色节点。
|
||
> * **作用**：操作系统线程，**真正执行代码**的实体。
|
||
> * **绑定**：M 必须绑定一个 P 才能执行 G。M 和 P 是**动态绑定**的。
|
||
> 4. **全局队列 (Global Queue)**：橙色节点。
|
||
> * **作用**：存放新创建的 G，当 P 的本地队列满时，或启动时，G 会进入全局队列。
|
||
> * **调度频率**：P 优先从本地队列取 G，只有本地队列为空时，才会尝试从全局队列或**窃取**其他 P 的 G。
|
||
|
||
### 🔄 调度流程：从创建到执行
|
||
|
||
```mermaid
|
||
sequenceDiagram
|
||
participant App as 应用程序
|
||
participant P as P (逻辑处理器)
|
||
participant M as M (线程)
|
||
participant OS as 操作系统
|
||
|
||
App->>P: 创建 G，放入本地队列
|
||
Note over P: 本地队列未满
|
||
P->>M: M 已绑定 P，检查本地队列
|
||
M->>G: 取出 G 并执行
|
||
alt G 阻塞 (如 IO)
|
||
G->>OS: 发起系统调用
|
||
OS-->>M: M 阻塞
|
||
Note over P: P 脱离 M，继续调度其他 G
|
||
P->>P: 寻找新 M (或创建新 M)
|
||
P->>NewM: 绑定新 M，继续执行
|
||
else G 完成
|
||
G->>M: 执行完毕
|
||
M->>P: 归还 P
|
||
end
|
||
```
|
||
|
||
> **📖 深度解析（关键优化）：**
|
||
> * **阻塞处理**：当 G 阻塞（如 IO），M 也会阻塞。Go 的优化：P 会**脱离** M，并寻找/创建新 M 继续执行其他 G。
|
||
> * **结果**：P 始终有 M 执行，不会因为某个 G 阻塞而停滞。
|
||
> * **工作窃取**：当 P 的本地队列为空，会从其他 P 的队列**窃取一半 G**，实现负载均衡。
|
||
|
||
> **🎮 动手练一练：**
|
||
> 1. 运行 `runtime.GOMAXPROCS(0)` 查看当前 P 的数量。
|
||
> 2. 尝试设置 `runtime.GOMAXPROCS(1)`，观察并发性能变化。
|
||
|
||
---
|
||
|
||
## 5.3 Channel —— Goroutine 之间的“传纸条”
|
||
|
||
> **💡 想象一下：**
|
||
> 你有两个小助手（Goroutine），A 负责生产数据，B 负责消费数据。
|
||
> 它们不能直接共享内存（会打架），怎么办？
|
||
> 于是，你放了一个**传送带**（Channel）在中间。A 把数据放上去，B 从上面拿走。
|
||
>
|
||
> 这就是 **Channel**：**Goroutine 之间通信的管道**。
|
||
|
||
### 📖 Channel 的底层结构（图解）
|
||
|
||
```mermaid
|
||
graph LR
|
||
subgraph "hchan 结构体"
|
||
qcount[qcount: 数据量]
|
||
dataqsiz[dataqsiz: 缓冲区大小]
|
||
buf[buf: 环形缓冲区]
|
||
sendx[sendx: 发送索引]
|
||
recvx[recvx: 接收索引]
|
||
sendq[sendq: 发送等待队列]
|
||
recvq[recvq: 接收等待队列]
|
||
lock[lock: 互斥锁]
|
||
|
||
qcount --> dataqsiz
|
||
dataqsiz --> buf
|
||
sendx --> sendq
|
||
recvx --> recvq
|
||
lock -.-> qcount
|
||
lock -.-> sendx
|
||
lock -.-> recvx
|
||
end
|
||
|
||
style hchan fill:#ffeb3b,stroke:#333
|
||
style lock fill:#f44336,stroke:#333,color:#fff
|
||
```
|
||
|
||
> **📖 深度解析：**
|
||
> * **buf**：环形缓冲区，存储数据。
|
||
> * **sendx/recvx**：发送/接收索引，环形移动。
|
||
> * **sendq/recvq**：等待队列，存放阻塞的 Goroutine。
|
||
> * **lock**：互斥锁，保证并发安全。
|
||
|
||
### 📝 Channel 的创建与使用
|
||
|
||
```go
|
||
// 1. 无缓冲 Channel (同步)
|
||
ch1 := make(chan int)
|
||
go func() { ch1 <- 42 }()
|
||
val := <-ch1 // 阻塞直到有数据
|
||
|
||
// 2. 有缓冲 Channel (异步)
|
||
ch2 := make(chan int, 2)
|
||
ch2 <- 1
|
||
ch2 <- 2
|
||
// ch2 <- 3 // 阻塞（缓冲区满）
|
||
val1 := <-ch2
|
||
val2 := <-ch2
|
||
```
|
||
|
||
> **💡 老师的小揭秘：**
|
||
> * **无缓冲**：发送和接收必须**同时就绪**（同步通信）。
|
||
> * **有缓冲**：发送直到缓冲区满，接收直到缓冲区空（异步通信）。
|
||
> * **关闭**：`close(ch)`，接收方用 `val, ok := <-ch` 判断是否关闭。
|
||
|
||
### ⚠️ 常见陷阱：忘记关闭
|
||
|
||
```go
|
||
func leak() {
|
||
ch := make(chan int)
|
||
go func() {
|
||
ch <- 1
|
||
// 忘记关闭！接收方会一直阻塞
|
||
}()
|
||
<-ch
|
||
}
|
||
```
|
||
|
||
> **💡 老师的小提醒：**
|
||
> * **谁发送，谁关闭**：通常由发送方关闭 Channel。
|
||
> * **不要重复关闭**：会 panic。
|
||
> * **不要向已关闭的 Channel 发送**：会 panic。
|
||
|
||
> **🎮 动手练一练：**
|
||
> 1. 创建一个无缓冲 Channel，启动一个 Goroutine 发送数据，主函数接收。
|
||
> 2. 创建一个容量为 3 的 Channel，循环发送 5 个数据，观察阻塞行为。
|
||
|
||
---
|
||
|
||
## 5.4 同步原语 —— 避免“打架”
|
||
|
||
> **🤔 多个 Goroutine 同时修改同一个变量，会发生什么？**
|
||
> 比如两个 Goroutine 同时 `count++`，结果可能少 1。这就是**竞态条件 (Race Condition)**。
|
||
>
|
||
> 我们需要**同步原语**来保护共享资源。
|
||
|
||
### 📝 WaitGroup —— 等待所有任务完成
|
||
|
||
```go
|
||
var wg sync.WaitGroup
|
||
|
||
for i := 0; i < 5; i++ {
|
||
wg.Add(1)
|
||
go func(id int) {
|
||
defer wg.Done()
|
||
fmt.Println("任务", id, "完成")
|
||
}(i)
|
||
}
|
||
|
||
wg.Wait() // 等待所有任务完成
|
||
fmt.Println("所有任务完成")
|
||
```
|
||
|
||
> **💡 老师的小揭秘：**
|
||
> * `Add(n)`：增加计数器。
|
||
> * `Done()`：减 1（通常用 `defer`）。
|
||
> * `Wait()`：阻塞直到计数器为 0。
|
||
|
||
### 📝 Mutex —— 互斥锁
|
||
|
||
```go
|
||
var mu sync.Mutex
|
||
var count int
|
||
|
||
go func() {
|
||
mu.Lock()
|
||
count++
|
||
mu.Unlock()
|
||
}()
|
||
```
|
||
|
||
> **💡 老师的小提醒：**
|
||
> * **Lock/Unlock**：加锁/解锁。
|
||
> * **死锁**：避免嵌套锁，保持锁顺序。
|
||
> * **RWMutex**：读多写少时，用读写锁（`RLock`/`Unlock`）。
|
||
|
||
### 📝 Once —— 只执行一次
|
||
|
||
```go
|
||
var once sync.Once
|
||
func init() {
|
||
once.Do(func() {
|
||
fmt.Println("只执行一次")
|
||
})
|
||
}
|
||
```
|
||
|
||
> **🎮 动手练一练：**
|
||
> 1. 用 `WaitGroup` 启动 10 个 Goroutine，统计它们的运行时间。
|
||
> 2. 用 `Mutex` 保护一个共享计数器，验证并发安全。
|
||
|
||
---
|
||
|
||
## 5.5 Context —— 统一“叫停”
|
||
|
||
> **💡 想象一下：**
|
||
> 老板（主函数）说：“停止所有任务！”
|
||
> 每个小助手（Goroutine）都要收到这个信号，并优雅地退出。
|
||
>
|
||
> 这就是 **Context**：传递取消信号、超时控制。
|
||
|
||
### 📝 Context 的用法
|
||
|
||
```go
|
||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
||
defer cancel()
|
||
|
||
go func() {
|
||
select {
|
||
case <-time.After(3 * time.Second):
|
||
fmt.Println("任务完成")
|
||
case <-ctx.Done():
|
||
fmt.Println("任务取消:", ctx.Err())
|
||
}
|
||
}()
|
||
|
||
time.Sleep(3 * time.Second)
|
||
```
|
||
|
||
> **💡 老师的小揭秘：**
|
||
> * `WithTimeout`：超时自动取消。
|
||
> * `WithCancel`：手动取消。
|
||
> * **树状传播**：父 Context 取消，所有子 Context 自动取消。
|
||
|
||
> **🎮 动手练一练：**
|
||
> 写一个函数，模拟耗时任务，用 Context 设置 1 秒超时，观察任务是否被取消。
|
||
|
||
---
|
||
|
||
## 5.6 本章小结
|
||
|
||
> **🎯 我们学到了什么？**
|
||
> 1. **Goroutine**：轻量级线程，`go` 启动。
|
||
> 2. **GMP 模型**：G/M/P 调度，用户态切换，高效。
|
||
> 3. **Channel**：通信管道，同步/异步，避免共享内存。
|
||
> 4. **同步原语**：WaitGroup、Mutex、Once，保护共享资源。
|
||
> 5. **Context**：取消信号，超时控制，树状传播。
|
||
>
|
||
> **🚀 下一步预告：**
|
||
> 学会了并发，我们怎么把这些知识**应用到实际项目**中？
|
||
>
|
||
> **下一章，我们要构建一个完整的 Web API 服务！** 我们会用 Goroutine 处理请求，用 Channel 处理异步任务，用 Context 控制超时，用 Mutex 保护共享状态。准备好迎接**实战**了吗？
|