124 lines
4.7 KiB
Markdown
124 lines
4.7 KiB
Markdown
---
|
||
id: backend.go.errors-concurrency
|
||
title: 错误处理和并发：goroutine、channel、context
|
||
type: lesson
|
||
domain: backend
|
||
stack: [go]
|
||
tags: [Go, 错误处理, goroutine, channel, context, 并发]
|
||
level: intermediate
|
||
prerequisites: [backend.go.basics-types]
|
||
est_hours: 4
|
||
related: [backend.go.scenario.batch-third-party-calls, backend.go.interview]
|
||
week: [1, 3]
|
||
order: 2
|
||
---
|
||
|
||
# 错误处理和并发：goroutine、channel、context
|
||
|
||
## 解释说明
|
||
|
||
**错误处理**
|
||
|
||
- 错误是普通的值。用 `fmt.Errorf("读取配置: %w", err)` **包装**错误，保留原始错误并加上下文；调用方用 `errors.Is(err, ErrNotFound)` 判断是不是某个错误，用 `errors.As(err, &target)` 取出某种类型的错误。
|
||
- 只在真正不可恢复的情况下用 `panic`（例如程序启动时配置缺失）；HTTP 服务里用中间件 `recover`，防止一个请求的 panic 让整个进程退出。
|
||
|
||
**并发**
|
||
|
||
- **goroutine**：`go f()` 启动一个轻量级“线程”（初始栈几 KB，由 Go 运行时调度到系统线程上），可以轻松开成千上万个。
|
||
- **channel**：goroutine 之间传递数据的管道。无缓冲 channel 收发双方要同时就绪；有缓冲 channel 满了才阻塞发送。“不要通过共享内存来通信，而要通过通信来共享内存。”
|
||
- **select**：同时等待多个 channel，哪个先就绪处理哪个；常用来实现超时和取消。
|
||
- **sync**：`WaitGroup` 等待一组 goroutine 结束；`Mutex` / `RWMutex` 保护共享数据；`Once` 只执行一次。
|
||
- **context**：在调用链上传递**取消信号、超时和请求范围的值**。HTTP 请求进来时创建，往下传给数据库查询、外部调用；客户端断开或超时，下游全部及时停止。约定：`ctx` 作为函数的第一个参数。
|
||
|
||
## 案例
|
||
|
||
- 一个接口要同时查用户信息、订单列表、优惠券三个下游服务：三个 goroutine 并发查询，整体用 `context.WithTimeout` 限制 2 秒，任一失败就取消其他的（`errgroup` 的典型用法）。
|
||
- 消息消费者：从队列取消息、交给固定数量的 worker 处理（worker pool），服务关闭时通过 `context` 通知 worker 处理完手上的消息再退出。
|
||
|
||
## 代码示例
|
||
|
||
一个带超时和取消的 worker pool：
|
||
|
||
```go
|
||
package main
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"fmt"
|
||
"sync"
|
||
"time"
|
||
)
|
||
|
||
var ErrInvalid = errors.New("无效的任务")
|
||
|
||
func process(ctx context.Context, n int) (int, error) {
|
||
if n < 0 {
|
||
return 0, fmt.Errorf("处理 %d: %w", n, ErrInvalid) // 包装错误
|
||
}
|
||
select {
|
||
case <-time.After(time.Duration(n) * 10 * time.Millisecond): // 模拟耗时操作
|
||
return n * n, nil
|
||
case <-ctx.Done(): // 超时或被取消
|
||
return 0, ctx.Err()
|
||
}
|
||
}
|
||
|
||
func main() {
|
||
ctx, cancel := context.WithTimeout(context.Background(), 150*time.Millisecond)
|
||
defer cancel()
|
||
|
||
jobs := make(chan int)
|
||
type result struct {
|
||
n, v int
|
||
err error
|
||
}
|
||
results := make(chan result)
|
||
|
||
var wg sync.WaitGroup
|
||
for w := 0; w < 3; w++ { // 3 个 worker
|
||
wg.Add(1)
|
||
go func() {
|
||
defer wg.Done()
|
||
for n := range jobs { // jobs 关闭后循环结束
|
||
v, err := process(ctx, n)
|
||
results <- result{n, v, err}
|
||
}
|
||
}()
|
||
}
|
||
go func() {
|
||
for _, n := range []int{1, 2, -1, 3, 50} {
|
||
jobs <- n
|
||
}
|
||
close(jobs) // 发送方负责关闭
|
||
}()
|
||
go func() { wg.Wait(); close(results) }() // 全部 worker 结束后关闭结果通道
|
||
|
||
for r := range results {
|
||
switch {
|
||
case errors.Is(r.err, ErrInvalid):
|
||
fmt.Println(r.n, "参数错误：", r.err)
|
||
case errors.Is(r.err, context.DeadlineExceeded):
|
||
fmt.Println(r.n, "超时")
|
||
default:
|
||
fmt.Println(r.n, "=>", r.v)
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
运行：`go run main.go`，再用 `go run -race main.go` 检查数据竞争。完整的生产写法（并发上限、单次超时、部分失败）见 [examples/batch-fetch](examples/batch-fetch/)。
|
||
|
||
## 易错点
|
||
|
||
- **goroutine 泄漏**：goroutine 阻塞在没人接收的 channel 上永远不退出。每个 goroutine 都要想清楚“它什么时候结束”，配合 `context` 或关闭 channel。
|
||
- **向已关闭的 channel 发送会 panic**；关闭的责任在发送方，多个发送方时用 `WaitGroup` 等全部结束再关闭。
|
||
- **循环变量**：Go 1.22 起每次循环都是新变量，旧版本里在 goroutine 中直接用循环变量会全部拿到最后一个值。
|
||
- **map 不是并发安全的**：多个 goroutine 同时读写会直接崩溃（fatal error），用 `Mutex` 或 `sync.Map`。
|
||
- **把 context 存进结构体**：context 应该随调用传递，不要长期保存。
|
||
- **吞掉错误**：`_ = f()` 要有理由；记录日志和返回错误二选一，不要两个都做（会重复打印）。
|
||
|
||
## 面试常问
|
||
|
||
见 [Go 面试题](interview.md)：GMP 调度、channel 的阻塞规则、context 的用途、如何发现数据竞争。
|