罗罗编程学习记录
本页内容 展开查看

05.4 阶段 3 并发模型

所属:全栈开发面试题库 / 学习路径 / 05 Go 全栈

本页目录

一、阶段定位

阶段 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 泄漏

自测题:

  1. GMP 三个字母各是什么?work stealing 怎么工作?
    • 要点:G 是 goroutine、M 是 OS 线程、P 是逻辑处理器;空闲 P 从其他 P 本地队列偷 G。
  2. 无缓冲与有缓冲 channel 的区别?为什么说"无缓冲是会合"?
    • 要点:无缓冲要求发送与接收同时就绪;有缓冲在缓冲未满/未空时不阻塞。
  3. close(ch) 由谁负责?关闭后再发送会怎样?
    • 要点:发送方负责;关闭后发送 panic(send on closed channel)。
  4. context.WithTimeout 后为什么必须 defer cancel()?
    • 要点:不 cancel 会泄漏内部 timer,直到 parent 取消;即使超时也必须调。
  5. sync.Mutex 与 sync.RWMutex 怎么选?atomic 什么时候用?
    • 要点:读多写少用 RWMutex;简单计数用 atomic;复杂临界区用 Mutex。
  6. fatal error: all goroutines are asleep - deadlock! 是什么意思?
    • 要点:所有 goroutine 都在阻塞,没有可运行的;通常是主 goroutine 等一个没人发送的 channel。