05.4 阶段 3 并发模型
本页目录
一、阶段定位
阶段 2(05.3)解决的是"模块之间怎么协作",本阶段解决的是"一个进程内多个执行流怎么协作"。Go 的并发模型与 Java 的 Thread、Python 的 threading 完全不同:goroutine 不是线程,channel 不是锁,context 不是线程本地存储。把这三者当成熟悉概念的替代品,一定会在"goroutine 泄漏""请求取消不生效""数据竞争"这三个坑里反复摔。
与前后阶段的衔接:
- 往上接阶段 1 的 slice/map 并发限制:阶段 1 讲过裸 map 不能并发写,本阶段讲为什么、以及怎么用
sync.RWMutex、sync.Map或 channel 正确地写。 - 往下接阶段 4(05.5):并发程序的内存问题(goroutine 泄漏、
sync.Pool误用)要用 pprof 定位,本阶段先建立"每个 goroutine 都要有退出路径"的纪律。 - 再往下接阶段 5(05.6):HTTP 服务每请求一个 goroutine,超时控制靠
context,本阶段不打好 context 基础,超时取消就会变成"请求挂死在下游"。
原提纲里的"卡点"展开成可判断的现象依据:
- 以为 goroutine "用完即焚"不需要收尾:起了 100 个 goroutine 跑任务,主函数返回后进程还在,因为 goroutine 阻塞在 channel 上没退出。
- 忘记传
context.Context:函数签名是func GetUser(id string)而不是func GetUser(ctx context.Context, id string),下游超时后上层取消信号传不下去。 - 对共享数据不加同步却靠"直觉"保证正确:两个 goroutine 各自
count++,压测时少加了几次,却没跑-race。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
| 能解释 GMP 模型中 G、M、P 的职责与 work stealing 流程 | 能画出 P 本地队列、全局队列、sysmon 三条路径 |
| 能正确使用有缓冲/无缓冲 channel,知道 close 由发送方负责 | 写一个 worker pool 加 fan-in,所有 goroutine 都有退出路径 |
能用 context.WithTimeout / WithCancel 传递取消信号 |
下游 sleep 5s,上游 1s 取消后,下游能在 1s 内退出 |
| 能选择合适的同步原语(Mutex/RWMutex/WaitGroup/Once/atomic/Pool) | 对一段"计数 + 读多写少"的代码能说出为什么用 RWMutex 而不是 atomic |
能用 go test -race 发现并修复数据竞争 |
一个故意写坏的计数器在 -race 下报错,修复后干净 |
| 能识别 goroutine 泄漏并给出修复 | 写一个"channel 永远阻塞"的最小复现,再用 context 修复 |
建议学时:
- 全职:2–3 周,约 70–80 小时。GMP 与 channel 20 小时、context 10 小时、sync 包 15 小时、worker pool 与 fan-in/fan-out 20 小时、-race 与排障 15 小时。
- 在职:5–6 周,约 80 小时。channel 与 context 各占一周,sync 与并发模式各占一周。
学时分配建议:goroutine 与 GMP 15%、channel 与 select 20%、context 15%、sync 包 20%、并发模式(worker pool/fan-in/fan-out)20%、-race 与排障 10%。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| slice 与 map 并发限制 | 知道裸 map 不能并发写,能复现 fatal error: concurrent map writes |
05.2 的 5.6 节 |
| 值/指针接收者 | 知道 sync.Mutex 不能复制 |
05.2 的 5.4 节 |
| defer 与错误 | 能用 defer 关闭资源 | 05.2 的 5.7 节 |
| 接口 | 能写一个小接口并依赖它 | 05.3 的 5.1 节 |
| 错误包装 | 能用 %w 保留错误链 |
05.3 的 5.3 节 |
经验判断:有 Java 经验的人最容易把 goroutine 当 Thread 用——到处起、不管理、不取消;有 Node.js 经验的人容易误用 channel 做"事件总线",结果多个发送方抢一个 channel 导致消息错乱。
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| goroutine 与 GMP | G/M/P、work stealing、sysmon、抢占式调度 | 能讲清原理 | 04.3 Go |
| channel | 有缓冲/无缓冲、close 语义、方向限制、nil channel | 能讲清原理 | 04.3 Go |
| select | 多 channel 等待、超时分支、随机选择、default | 会用 | 04.3 Go |
| context | 取消传播、超时、值传递、CancelFunc | 能讲清原理 | 04.3 Go |
| sync 包 | Mutex/RWMutex/WaitGroup/Once/Pool/atomic | 能讲清原理 | 04.3 Go |
| 竞态检测 | -race、happens-before、数据竞争 |
会用 | 04.3 Go |
| 并发模式 | worker pool、fan-in/fan-out、pipeline、限流 | 会用 | 09.1 高并发基础 |
进度管理建议:GMP 与 channel 是面试高频,必须到"能讲清原理";并发模式要求"会用",能照着写出 worker pool 即可。
五、分模块精讲
5.1 goroutine 与 GMP 调度模型
为什么需要它:goroutine 不是线程。一个 Go 进程可以跑几十万个 goroutine,而 OS 线程通常只有几十个。理解 GMP 是理解"为什么 Go 并发这么轻""为什么 GOMAXPROCS 要设成容器 CPU 数"的前提。
核心机制:
- G:goroutine,初始栈仅 2 KB,可按需增长(最大 1 GB),由 Go 运行时调度,不是 OS 线程。
- M:OS 线程,真正执行代码的载体;数量受系统限制(默认 10000)。
- P:逻辑处理器,数量默认等于
GOMAXPROCS(即 CPU 核数);每个 P 持有一个本地可运行 G 队列(容量 256)。 - M 必须绑定一个 P 才能执行 G;P 的本地队列空了就从全局队列(长度 128)取,再空就从其他 P 那里偷(work stealing)。
- sysmon 是运行时后台线程,不绑定 P,负责:抢占用时过长的 G(10 ms 以上,防止纯计算饿死其他 goroutine)、回收 syscall 阻塞的 M、触发 GC。
- 阻塞在 syscall 的 M 会被 P "卸下":P 挂到其他 M 上继续跑队列,等 syscall 返回,原 M 再尝试拿一个 P。
最小可运行示例:
package main
import (
"fmt"
"runtime"
"sync"
)
func main() {
fmt.Println("GOMAXPROCS =", runtime.GOMAXPROCS(0)) // 默认等于 CPU 核数
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
fmt.Printf("goroutine %d on M\n", i)
}(i)
}
wg.Wait()
// 容器里要手动设置,否则会按宿主机核数算
runtime.GOMAXPROCS(2) // 限制为 2 个 P
}
# 查看容器内 CPU 配额下的 GOMAXPROCS 错配
# 宿主机 16 核,容器限制 2 核,不设置时 GOMAXPROCS=16,调度过度竞争
# Go 1.19 起 runtime 自动识别 cgroup 限制;老版本需要手动设置
go run .
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 容器里 CPU 使用率高但吞吐上不去 | GOMAXPROCS 按宿主机核数算,P 太多互相抢 | Go 1.19+ 自动识别;老版本用 runtime.GOMAXPROCS(2) 或 automaxprocs 库 |
| 起了 10 万 goroutine 后内存暴涨 | 每个 goroutine 栈最小 2 KB,10 万就是 200 MB | 用 worker pool 限制并发度,不要无限起 |
| 纯计算任务把其他 goroutine 饿死 | sysmon 抢占前一直占着 M | sysmon 会在 10 ms 后抢占;或主动 runtime.Gosched() 让出 |
面试考法:"GMP 模型三个字母各是什么""work stealing 怎么工作""sysmon 干什么""为什么容器里要设 GOMAXPROCS"。要答到:P 是逻辑处理器、M 是 OS 线程、G 是 goroutine;work stealing 让空闲 P 从其他 P 队列偷;sysmon 做抢占、syscall 分离、GC 触发;GOMAXPROCS 不匹配 cgroup 配额会导致调度抖动。
5.2 channel 与 select
为什么需要它:channel 是 goroutine 之间通信与同步的首选原语。Go 的设计哲学是"不要通过共享内存来通信,而要通过通信来共享内存"。用错 channel(关闭责任不清、nil channel 误用)是 goroutine 泄漏的头号原因。
核心机制:
- 无缓冲 channel:发送方与接收方必须同时就绪才完成传递(会合);一方先到就阻塞。
- 有缓冲 channel:缓冲未满时发送不阻塞,缓冲未空时接收不阻塞;满了才阻塞。
close(ch):通知接收方不再有新值;接收方用v, ok := <-ch判断ok=false表示已关闭。- 关闭后再发送会 panic(
send on closed channel);关闭后再接收仍能取到缓冲里的值,之后取零值。 - nil channel:发送与接收都永久阻塞;在
select中把某个 case 设为 nil 可以临时禁用它。 - 方向限制:
chan<- int只能发送、<-chan int只能接收,编译器强制。 - 关闭责任:由发送方负责关闭,不要让接收方关(发送方不知道什么时候该关)。
最小可运行示例:
package main
import (
"fmt"
"time"
)
// 生产者:发送 5 个数字后关闭 channel
func produce(ch chan<- int) {
defer close(ch) // 发送方负责关闭
for i := 0; i < 5; i++ {
ch <- i
time.Sleep(100 * time.Millisecond)
}
}
// 消费者:用 range 读取直到 channel 关闭
func consume(ch <-chan int) {
for v := range ch { // 自动检测 close
fmt.Println("got", v)
}
fmt.Println("channel closed, consumer exits")
}
func main() {
ch := make(chan int, 2) // 缓冲 2
go produce(ch)
consume(ch)
}
// select 与超时分支
func callWithTimeout() error {
ch := make(chan string, 1)
go func() {
time.Sleep(2 * time.Second) // 模拟慢操作
ch <- "result"
}()
select {
case v := <-ch:
fmt.Println("got:", v)
return nil
case <-time.After(500 * time.Millisecond):
return fmt.Errorf("timeout")
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
panic: send on closed channel |
接收方关闭了 channel,发送方还在写 | 关闭责任归发送方;或用 sync.Once + ok 检测 |
fatal error: all goroutines are asleep - deadlock! |
主 goroutine 等一个没人发送的 channel | 检查是否有发送方;用 select + default 或超时 |
| goroutine 泄漏:主函数返回后进程不退出 | 接收方永远等不到 close,goroutine 阻塞 | 用 context 取消;确保发送方在退出前 close |
| select 多个 case 同时就绪时执行顺序不确定 | Go 随机选择避免饥饿 | 不要依赖顺序;需要顺序时用 if-else |
面试考法:"无缓冲与有缓冲的区别""close 由谁负责""nil channel 有什么用""select 随机选择为什么"。要点:无缓冲是会合;关闭归发送方;nil channel 在 select 中禁用 case;随机选择防止饥饿。
5.3 context 与取消传播
为什么需要它:一个 HTTP 请求可能要调用用户服务、订单服务、库存服务。用户取消了请求,下游所有调用都要能一起退出,否则 goroutine 会泄漏、连接池会被占满。context.Context 就是沿调用链传递取消信号与截止时间的标准方式。
核心机制:
context.Context是接口,四个核心方法:Deadline()、Done() <-chan struct{}、Err() error、Value(key any) any。context.Background()是根 context,用于 main 或测试;context.TODO()用于还不确定用什么时的占位。ctx, cancel := context.WithCancel(parent):子 context 在 parent 取消时自动取消;WithTimeout与WithDeadline是自动版本。- 调用
cancel()是强制的——即使 context 已经超时,不调用会泄漏内部资源(直到 parent 取消)。用defer cancel()。 ctx.Done()返回一个 channel,在取消时被关闭;select监听它实现退出。ctx.Value用于传递请求级元数据(如 request id、trace id),不要用来传函数参数(会让 API 不清晰)。
最小可运行示例:
package main
import (
"context"
"fmt"
"time"
)
// 模拟下游操作:必须接收 ctx 才能响应取消
func queryDB(ctx context.Context, id string) (string, error) {
ch := make(chan string, 1)
go func() {
time.Sleep(2 * time.Second) // 模拟慢查询
ch <- "user:" + id
}()
select {
case v := <-ch:
return v, nil
case <-ctx.Done():
return "", ctx.Err() // context canceled 或 deadline exceeded
}
}
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
defer cancel() // 必须调用,即使超时
v, err := queryDB(ctx, "100")
fmt.Println(v, err) // "" context deadline exceeded
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 下游 goroutine 不退出,主函数返回后进程仍在 | 下游没监听 ctx.Done() | 所有耗时函数接收 ctx,select 监听 Done |
cancel 没调用导致内部 timer 泄漏 |
WithTimeout 不 cancel 也会超时,但内部资源泄漏 |
永远 defer cancel() |
用 ctx.Value 传业务参数 |
API 不清晰,难以测试 | 业务参数显式传;Value 只放 request id/trace id |
| context 跨 goroutine 传递但被复制 | context 是不可变的,可以安全跨 goroutine | 直接传,不要传指针 |
面试考法:"context 的作用""为什么 cancel 必须调用""ctx.Value 适合放什么""如何让一个函数响应取消"。要点:沿调用链传递取消与超时;不 cancel 会泄漏 timer;Value 只放请求级元数据;select 监听 Done。
5.4 sync 包与同步原语
为什么需要它:不是所有并发问题都该用 channel。"共享计数器""读多写少的配置""只初始化一次"这类场景,用 channel 反而更慢、更复杂。sync 包提供了传统同步原语。
核心机制:
sync.Mutex:互斥锁,Lock/Unlock;适合写多或临界区较长。不可复制(go vet会报passes lock by value)。sync.RWMutex:读锁共享、写锁排他;适合读多写少(如配置)。sync.WaitGroup:计数同步,Add(n)加计数、Done()减一、Wait()等归零;必须先 Add 再 go。sync.Once:保证某段代码只执行一次;适合懒加载、单例初始化。sync.Pool:临时对象池,GC 时清空;适合复用[]byte等临时对象,不适合存连接(连接池该用数据库客户端自带的)。sync/atomic:无锁原子操作,用于简单计数与标志位;比 mutex 快但功能有限。
最小可运行示例:
package main
import (
"fmt"
"sync"
"sync/atomic"
)
func main() {
// 1. Mutex:计数器
var (
mu sync.Mutex
count int64
wg sync.WaitGroup
)
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
mu.Lock()
count++
mu.Unlock()
}()
}
wg.Wait()
fmt.Println("mutex count =", count) // 1000
// 2. atomic:更简单的计数
var acount int64
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
atomic.AddInt64(&acount, 1)
}()
}
wg.Wait()
fmt.Println("atomic count =", acount) // 1000
// 3. Once:只初始化一次
var once sync.Once
config := ""
for i := 0; i < 10; i++ {
once.Do(func() { config = "loaded" })
}
fmt.Println(config) // loaded
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 压测下计数器少加 | 没用锁或 atomic,两个 goroutine 同时 ++ | 用 atomic.AddInt64 或 Mutex |
go vet 报 passes lock by value |
struct 复制时把 Mutex 也复制了 | 用指针接收者或指针传 struct |
sync.Pool 里的对象突然消失 |
GC 时 Pool 被清空 | Pool 只用于临时对象,不要存需要持久的状态 |
WaitGroup 计数不对 |
Add 在 go 之后才调用 |
先 Add(1) 再 go func |
面试考法:"Mutex 与 RWMutex 怎么选""atomic 与 Mutex 怎么选""sync.Once 实现原理""sync.Pool 适合什么"。要点:读多写少用 RWMutex;简单计数用 atomic;Once 用双检查 + 锁;Pool 复用临时对象不存连接。
5.5 竞态检测(-race)
为什么需要它:数据竞争是并发程序最难排查的 bug——平时好好的,压测时偶发。go test -race 基于 ThreadSanitizer,能在测试阶段就报告"哪个 goroutine 在什么时候读写了哪个变量、缺了什么同步"。
核心机制:
-race在编译时插入检测逻辑,运行时记录每个内存访问的 goroutine 与时间戳。- 报告格式:先打印
WARNING: DATA RACE,再列出两个 goroutine 的调用栈。 - 代价:CPU 与内存开销约 10 倍,不要在生产开,但 CI 里必须开。
- 它只检测"并发访问同一变量且没有同步",不是"所有并发问题"。
- happens-before:channel 发送 happens-before 接收完成;Mutex Unlock happens-before 下一次 Lock;WaitGroup Done happens-before Wait 返回。
最小可运行示例:
# 故意写坏的计数器
cat > race_test.go <<'EOF'
package main
import "testing"
func TestRace(t *testing.T) {
count := 0
done := make(chan struct{})
go func() {
count++ // 无锁写
done <- struct{}{}
}()
count++ // 主 goroutine 无锁写
<-done
_ = count
}
EOF
go test -race -run TestRace .
# 期望输出:WARNING: DATA RACE
# 列两个 goroutine 的栈
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
-race 报 WARNING: DATA RACE |
两个 goroutine 无锁访问同一变量 | 加 Mutex、用 atomic、或通过 channel 传递数据 |
-race 开销太大测试跑不动 |
全量测试都开 race | 只对并发相关测试开,或拆出 race test profile |
没跑 -race 上线后偶发错误 |
本地测试没开 | CI 里 go test -race ./... 作为必跑步骤 |
面试考法:"数据竞争是什么""happens-before 原则""-race 报告怎么读"。要点:并发访问同一变量且无同步;channel、锁、WaitGroup 都是同步点;CI 必跑。
5.6 并发模式:worker pool 与 fan-in/fan-out
为什么需要它:无限起 goroutine 会让 CPU 与连接池打满。worker pool 用固定数量的 worker 从任务队列取任务,控制并发度;fan-in 把多个 worker 的结果汇总到一个 channel。
核心机制:
- 任务 channel:发送方把任务发进去;N 个 worker 同时消费。
- 结果 channel:每个 worker 处理完发结果;fan-in goroutine 汇总。
- 关闭:任务 channel 在发送完所有任务后 close;worker 用
range退出;fan-in 用WaitGroup等所有 worker 退出后 close 结果 channel。 - 取消:所有函数接收
ctx,主调用方cancel()后所有 worker 退出。
最小可运行示例:
package main
import (
"context"
"fmt"
"sync"
"time"
)
// 任务
type Task struct{ ID int }
type Result struct { ID int; Dur time.Duration }
func worker(ctx context.Context, id int, tasks <-chan Task, results chan<- Result, wg *sync.WaitGroup) {
defer wg.Done()
for t := range tasks {
select {
case <-ctx.Done():
return
default:
}
start := time.Now()
time.Sleep(50 * time.Millisecond) // 模拟工作
results <- Result{ID: t.ID, Dur: time.Since(start)}
fmt.Printf("worker %d processed task %d\n", id, t.ID)
}
}
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
tasks := make(chan Task, 10)
results := make(chan Result, 10)
var wg sync.WaitGroup
for w := 0; w < 3; w++ { // 3 个 worker
wg.Add(1)
go worker(ctx, w, tasks, results, &wg)
}
// 发送任务
go func() {
for i := 0; i < 10; i++ {
tasks <- Task{ID: i}
}
close(tasks) // 发送方关闭
}()
// fan-in:等所有 worker 退出后关闭 results
go func() {
wg.Wait()
close(results)
}()
// 汇总结果
for r := range results {
fmt.Printf("result task %d took %v\n", r.ID, r.Dur)
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 主函数返回后 results 没读完 | 没等 results close 就退出 | 用 range results 等 close |
| worker 永远不退出 | tasks 没 close,worker 阻塞在 range | 发送完任务 close(tasks) |
| fan-in goroutine 泄漏 | wg.Wait 没等所有 worker | 确保每个 worker defer wg.Done |
| ctx 取消后 worker 还在跑 | worker 没 select ctx.Done | 在循环开头加 select |
面试考法:"worker pool 怎么控制并发度""fan-in 怎么汇总""怎么保证所有 goroutine 都退出"。要点:固定 worker 数;任务 channel close 后 worker range 退出;WaitGroup 等 worker 后 close results;ctx 取消作为兜底。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| GOMAXPROCS 实验 | 用 runtime.GOMAXPROCS(0) 看默认值,手动设 2 跑循环 |
能解释 P 数量与 CPU 核数关系 | 0.5 小时 |
| 无缓冲会合 | 写两个 goroutine 用无缓冲 channel 互传消息 | 能打印"发送方等待接收方"的阻塞现象 | 1 小时 |
| context 超时 | 写一个 2s 慢操作,上游 500ms 超时 | 下游在 500ms 后退出,ctx.Err() 为 deadline exceeded |
1 小时 |
| WaitGroup 计数 | 起 10 个 goroutine 计数到 1000 | 不用锁,用 atomic 或 WaitGroup | 0.5 小时 |
| -race 复现 | 故意写坏的计数器,跑 go test -race |
能读懂 race 报告的两个调用栈 | 1 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 修复 goroutine 泄漏 | 给定一个"channel 永远阻塞"的例子,加 context 修复 | 主函数返回时所有 goroutine 退出 | 1 小时 |
| Mutex 改 RWMutex | 给定一个读多写少的配置 struct,改用 RWMutex | -race 干净;读并发不互相阻塞 |
1 小时 |
| channel 改 select | 给定一个只等单 channel 的代码,加超时分支 | 超时后返回 error,不阻塞 | 0.5 小时 |
| worker pool 改造 | 给定无限起 goroutine 的代码,改成固定 worker | 并发度可控;任务排队不丢 | 2 小时 |
| 错误包装 + 取消 | 给下游函数加 ctx,错误信息带 context.Canceled |
errors.Is(err, context.Canceled) 命中 |
1 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 并发抓取工具 | 输入 URL 列表,N 个 worker 并发抓取,汇总状态码 | 控制并发度;支持 Ctrl+C 优雅退出 | 6 小时 |
| 限流器 | 用 channel + time.Ticker 实现令牌桶 | QPS 不超过上限;ctx 取消后退出 | 4 小时 |
| 任务队列 worker | 实现一个带优先级的任务队列,高优先级先消费 | 高优任务先处理;worker 数可配 | 5 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
fatal error: all goroutines are asleep - deadlock! |
主 goroutine 等一个没人发送的 channel | 打印 goroutine 栈(pprof goroutine) |
检查发送方;加超时分支 |
panic: send on closed channel |
接收方关闭了 channel,发送方还在写 | 看 panic 栈 | 关闭归发送方;用 sync.Once 保护 |
| 主函数返回后进程不退出 | 有 goroutine 阻塞在 channel 或 ctx 没取消 | pprof goroutine 看阻塞位置 |
加 context 取消;确保 close 责任清晰 |
| 计数器压测下少加 | 无锁并发 ++ | go test -race |
用 atomic 或 Mutex |
| 下游调用不响应取消 | 函数没接收 ctx | 看函数签名 | 所有耗时函数接收 ctx,select Done |
| 容器里 CPU 飙高吞吐低 | GOMAXPROCS 按宿主机核数 | runtime.GOMAXPROCS(0) 打印 |
用 automaxprocs 或手动设 |
-race 报数据竞争 |
两个 goroutine 无锁访问同一变量 | 读 race 报告的两个栈 | 加锁、用 atomic 或 channel |
sync.Pool 里的对象突然没了 |
GC 时 Pool 被清空 | 在 GC 前后打印 | Pool 只存临时对象,不存持久状态 |
八、出口条件
全部勾选后再进入 05.5 阶段 4 内存、运行时与性能分析。
- [ ] 能画出 GMP 模型的 G/M/P 关系,说清 work stealing 与 sysmon 职责
- [ ] 能正确使用有缓冲/无缓冲 channel,知道 close 由发送方负责
- [ ] 能用
context.WithTimeout让下游函数在超时后退出 - [ ] 能选择合适的同步原语(Mutex/RWMutex/atomic/Once/Pool)
- [ ] 能用
go test -race发现并修复数据竞争 - [ ] 能写出带取消的 worker pool + fan-in,所有 goroutine 都有退出路径
- [ ] 能复现并修复一个 goroutine 泄漏
自测题:
- GMP 三个字母各是什么?work stealing 怎么工作?
- 要点:G 是 goroutine、M 是 OS 线程、P 是逻辑处理器;空闲 P 从其他 P 本地队列偷 G。
- 无缓冲与有缓冲 channel 的区别?为什么说"无缓冲是会合"?
- 要点:无缓冲要求发送与接收同时就绪;有缓冲在缓冲未满/未空时不阻塞。
close(ch)由谁负责?关闭后再发送会怎样?- 要点:发送方负责;关闭后发送 panic(
send on closed channel)。
- 要点:发送方负责;关闭后发送 panic(
context.WithTimeout后为什么必须defer cancel()?- 要点:不 cancel 会泄漏内部 timer,直到 parent 取消;即使超时也必须调。
sync.Mutex与sync.RWMutex怎么选?atomic什么时候用?- 要点:读多写少用 RWMutex;简单计数用 atomic;复杂临界区用 Mutex。
fatal error: all goroutines are asleep - deadlock!是什么意思?- 要点:所有 goroutine 都在阻塞,没有可运行的;通常是主 goroutine 等一个没人发送的 channel。