329 lines
8.0 KiB
Markdown
329 lines
8.0 KiB
Markdown
# 第五章：并发编程 —— Goroutine 与 Channel 的艺术（图解版）
|
||
|
||
> **本章目标**：深入理解 Go 并发的核心机制，**配合大量图解**，掌握 Goroutine 调度原理、Channel 通信模式、同步原语等。
|
||
|
||
## 5.1 并发基础与 Goroutine
|
||
|
||
### 5.1.1 并发 vs 并行（图解）
|
||
|
||
```mermaid
|
||
graph LR
|
||
subgraph 并发 Concurrency
|
||
A[任务 1] -->|交替执行 | B(时间片 1)
|
||
A -->|交替执行 | C(时间片 3)
|
||
D[任务 2] -->|交替执行 | B
|
||
D -->|交替执行 | C
|
||
style A fill:#f9f,stroke:#333
|
||
style D fill:#f9f,stroke:#333
|
||
end
|
||
|
||
subgraph 并行 Parallelism
|
||
E[任务 1] -->|同时执行 | F(CPU 核心 1)
|
||
G[任务 2] -->|同时执行 | H(CPU 核心 2)
|
||
style E fill:#9f9,stroke:#333
|
||
style G fill:#9f9,stroke:#333
|
||
end
|
||
```
|
||
|
||
- **并发**：宏观上同时，微观上**交替**（单核也能实现）。
|
||
- **并行**：微观上**同时**（需要多核 CPU）。
|
||
|
||
---
|
||
|
||
## 5.2 GMP 调度模型 ⭐ 核心重点（图解）
|
||
|
||
Go 的并发性能得益于其独特的 **GMP 调度模型**。
|
||
|
||
### 5.2.1 GMP 模型架构（图解）
|
||
|
||
```mermaid
|
||
graph TB
|
||
subgraph "Go Runtime 用户态调度"
|
||
P1[P1: 逻辑处理器]
|
||
P2[P2: 逻辑处理器]
|
||
P3[P3: 逻辑处理器]
|
||
|
||
Q1[本地 G 队列]
|
||
Q2[本地 G 队列]
|
||
Q3[本地 G 队列]
|
||
|
||
P1 --- Q1
|
||
P2 --- Q2
|
||
P3 --- Q3
|
||
|
||
GlobalQ[全局 G 队列]
|
||
GlobalQ -.-> P1
|
||
GlobalQ -.-> P2
|
||
GlobalQ -.-> P3
|
||
end
|
||
|
||
subgraph "操作系统内核态"
|
||
M1[M1: 线程]
|
||
M2[M2: 线程]
|
||
M3[M3: 线程]
|
||
|
||
M1 <--> P1
|
||
M2 <--> P2
|
||
M3 <--> P3
|
||
end
|
||
|
||
subgraph "Goroutine 实体"
|
||
G1[G1: 协程]
|
||
G2[G2: 协程]
|
||
G3[G3: 协程]
|
||
G4[G4: 协程]
|
||
|
||
G1 --> Q1
|
||
G2 --> Q1
|
||
G3 --> Q2
|
||
G4 --> Q3
|
||
end
|
||
|
||
style P1 fill:#ffeb3b,stroke:#333
|
||
style M1 fill:#2196f3,stroke:#333,color:#fff
|
||
style G1 fill:#4caf50,stroke:#333,color:#fff
|
||
```
|
||
|
||
**图解说明**：
|
||
1. **G (Goroutine)**：绿色的协程，包含栈、指令指针。
|
||
2. **P (Processor)**：黄色的逻辑处理器，管理 G 队列，**数量 = CPU 核数**。
|
||
3. **M (Machine)**：蓝色的操作系统线程，真正执行代码。
|
||
4. **调度**：M 绑定 P，从 P 的本地队列取 G 执行。
|
||
|
||
### 5.2.2 调度流程：从创建到执行
|
||
|
||
```mermaid
|
||
sequenceDiagram
|
||
participant App as 应用程序
|
||
participant G as Goroutine
|
||
participant P as P (逻辑处理器)
|
||
participant M as M (线程)
|
||
participant OS as 操作系统
|
||
|
||
App->>P: 创建 G，放入本地队列
|
||
P->>M: M 绑定 P，获取 G
|
||
M->>G: 执行 G 代码
|
||
alt G 阻塞 (如 IO)
|
||
G->>OS: 发起系统调用
|
||
OS-->>M: M 阻塞
|
||
P->>P: 寻找新 M 继续调度其他 G
|
||
Note right of P: P 不阻塞，继续工作！
|
||
else G 完成
|
||
G->>M: 执行完毕
|
||
M->>P: 归还 P
|
||
end
|
||
```
|
||
|
||
### 5.2.3 工作窃取 (Work Stealing)
|
||
|
||
当某个 P 的队列为空时，它会从其他 P 的队列**窃取**一半的 G。
|
||
|
||
```
|
||
P1 队列：[G1, G2, G3, G4, G5] (满载)
|
||
P2 队列：[] (空闲)
|
||
|
||
P2 发现空 -> 向 P1 请求 -> P1 给 G4, G5
|
||
P1 队列：[G1, G2, G3]
|
||
P2 队列：[G4, G5] <-- 窃取成功！
|
||
```
|
||
|
||
---
|
||
|
||
## 5.3 Channel：Goroutine 间的通信（图解）
|
||
|
||
### 5.3.1 无缓冲 Channel (同步)
|
||
|
||
发送和接收必须**同时就绪**，否则阻塞。
|
||
|
||
```
|
||
发送方 (go func) 接收方 (main)
|
||
| |
|
||
| ch <- 42 |
|
||
| (阻塞等待) |
|
||
| <-------------------> | 数据传递 (42)
|
||
| | (同时发生)
|
||
v v
|
||
发送完成 接收完成
|
||
```
|
||
|
||
### 5.3.2 有缓冲 Channel (异步)
|
||
|
||
缓冲区未满时，发送不阻塞；缓冲区非空时，接收不阻塞。
|
||
|
||
```
|
||
缓冲区容量 = 2
|
||
|
||
发送方 缓冲区 接收方
|
||
| [ ] [ ] |
|
||
| ch <- 1 (成功) [1] [ ] |
|
||
| ch <- 2 (成功) [1] [2] |
|
||
| ch <- 3 (阻塞!) [1] [2] | (满了)
|
||
| [1] [2] | <-val (接收 1)
|
||
| [ ] [2] |
|
||
| ch <- 3 (成功!) [3] [2] |
|
||
| [3] [2] | <-val (接收 2)
|
||
| [3] [ ] |
|
||
```
|
||
|
||
### 5.3.3 Channel 状态机
|
||
|
||
```mermaid
|
||
stateDiagram-v2
|
||
[*] --> 未初始化
|
||
未初始化 --> 打开：make
|
||
打开 --> 打开：发送/接收
|
||
打开 --> 关闭：close()
|
||
关闭 --> 关闭：接收 (返回零值)
|
||
关闭 --> [*]：GC 回收
|
||
打开 --> [*]：GC 回收
|
||
|
||
note right of 打开
|
||
发送阻塞：缓冲区满
|
||
接收阻塞：缓冲区空
|
||
end note
|
||
```
|
||
|
||
---
|
||
|
||
## 5.4 同步原语 (图解)
|
||
|
||
### 5.4.1 WaitGroup 计数原理
|
||
|
||
```
|
||
初始：Counter = 0
|
||
|
||
Goroutine 1: Add(1) -> Counter = 1
|
||
Goroutine 2: Add(1) -> Counter = 2
|
||
Goroutine 3: Add(1) -> Counter = 3
|
||
|
||
Goroutine 1: Done() -> Counter = 2
|
||
Goroutine 2: Done() -> Counter = 1
|
||
Goroutine 3: Done() -> Counter = 0 (唤醒 Wait())
|
||
```
|
||
|
||
### 5.4.2 Mutex 锁状态
|
||
|
||
```mermaid
|
||
stateDiagram-v2
|
||
[*] --> 空闲：初始
|
||
空闲 --> 占用：Lock()
|
||
占用 --> 空闲：Unlock()
|
||
占用 --> 等待队列：Lock() (阻塞)
|
||
等待队列 --> 空闲：Unlock() (唤醒)
|
||
```
|
||
|
||
### 5.4.3 RWMutex 读写锁
|
||
|
||
```
|
||
读锁 (RLock)：允许多个读者同时持有
|
||
写锁 (Lock)：排他，只能有一个写者，且不能有读者
|
||
|
||
状态图：
|
||
[空闲] --R--> [多读] --R--> [多读]
|
||
| |
|
||
L L
|
||
v v
|
||
[写] <--------- [多读] (写者等待)
|
||
|
|
||
U
|
||
v
|
||
[空闲]
|
||
```
|
||
|
||
---
|
||
|
||
## 5.5 原子操作 (图解)
|
||
|
||
```
|
||
内存地址：0x1000 (值 = 5)
|
||
|
||
Goroutine 1: atomic.Add(0x1000, 1) -> 硬件级 CAS -> 值 = 6
|
||
Goroutine 2: atomic.Add(0x1000, 1) -> 硬件级 CAS -> 值 = 7
|
||
(无需锁，CPU 指令直接保证原子性)
|
||
```
|
||
|
||
---
|
||
|
||
## 5.6 Context 传递 (图解)
|
||
|
||
```mermaid
|
||
graph LR
|
||
Parent[父 Context] -->|WithTimeout| Child1[子 Context 1]
|
||
Parent -->|WithValue| Child2[子 Context 2]
|
||
|
||
Parent -- 取消 --> Cancel1[取消信号]
|
||
Child1 -- 传播 --> Cancel1
|
||
Child2 -- 传播 --> Cancel1
|
||
|
||
style Parent fill:#ff9800,stroke:#333
|
||
style Cancel1 fill:#f44336,stroke:#333,color:#fff
|
||
```
|
||
|
||
- **取消传播**：父 Context 取消，所有子 Context 自动取消。
|
||
- **超时传播**：父 Context 超时，子 Context 也超时。
|
||
|
||
---
|
||
|
||
## 5.7 竞态检测 (图解)
|
||
|
||
```
|
||
竞态 (Race Condition)：
|
||
Goroutine 1: 读 变量 X
|
||
Goroutine 2: 写 变量 X
|
||
(无锁，同时发生) -> 数据不一致！
|
||
|
||
Race Detector 检测：
|
||
Goroutine 1: 读 X (记录时间 T1)
|
||
Goroutine 2: 写 X (记录时间 T2)
|
||
T1 和 T2 重叠 -> 报告竞态！
|
||
```
|
||
|
||
---
|
||
|
||
## 5.8 并发设计模式 (图解)
|
||
|
||
### 5.8.1 管道 (Pipeline)
|
||
|
||
```
|
||
Stage 1 (生成) Stage 2 (平方) Stage 3 (输出)
|
||
[1,2,3] -----> [1,4,9] -----> 打印
|
||
| | |
|
||
(Chan A) (Chan B) (结果)
|
||
```
|
||
|
||
### 5.8.2 工作池 (Worker Pool)
|
||
|
||
```
|
||
任务队列 (100 个)
|
||
|
|
||
v
|
||
+-------------------+
|
||
| Worker 1 (处理) |
|
||
| Worker 2 (处理) | (并发执行)
|
||
| Worker 3 (处理) |
|
||
+-------------------+
|
||
|
|
||
v
|
||
结果队列
|
||
```
|
||
|
||
---
|
||
|
||
*(本章其余部分保持原有文字内容，此处仅展示图解核心)*
|
||
|
||
---
|
||
|
||
## 🎨 图解总结
|
||
|
||
1. **GMP 模型**：P 是调度器，M 是执行者，G 是任务。
|
||
2. **Channel**：无缓冲是同步，有缓冲是异步。
|
||
3. **锁**：Mutex 互斥，RWMutex 读写分离。
|
||
4. **Context**：树状结构，取消信号自顶向下传播。
|
||
5. **管道**：数据流式处理，解耦各阶段。
|
||
|
||
---
|
||
|
||
**代码仓库位置**：https://giter.top/openclaw/test/tree/main/chapters/chapter-5
|
||
|
||
**下一章预告**：HTTP 服务器、路由、中间件、数据库连接池、RESTful API 设计、部署
|