1 / 4概念
Async
Go 不提供 async/await,也不返回 future。异步由运行时调度:go 启动 goroutine,channel 或 context 取结果与取消。函数不会因为加了 go 就变成可等待对象,调用方必须自己决定在哪里等、等多久、放弃时怎么退出。
1 概念
1.1 一句话定义
Go 的异步是用 go 把等待移出当前 goroutine,用 channel 交接结果,用 context 传播取消;语言层面没有 await,等待就是当前 goroutine 阻塞,而不是把函数变成 Promise。
1.2 它解决什么问题
- 等待不占线程:I/O 阻塞时 M 可以解绑,P 继续调度其他 G。
- 取消与结果同路:超时与取消沿 context 树向下传递;一个结果结构体同时携带值与 error。
- 并发有上限:worker pool、信号量、
errgroup.SetLimit把压力挡在队列里。 - 异步与并理解耦:I/O 密集可以开很多 goroutine,CPU 密集只能按核数并行。
1.3 不属于本页的内容
| 主题 | 去哪 |
|---|---|
| GMP 调度、P 的本地队列与 work stealing | Concurrency |
channel 的阻塞、关闭与 select 语义 | Concurrency |
async/await 与 Promise 链 | JS Async and Concurrency |
GC 与 GOMEMLIMIT | Go Language |
1.4 关键术语
| 术语 | 含义 | 容易混淆的点 |
|---|---|---|
| goroutine | 运行时调度的执行单元 | 不是线程,没有 join 句柄 |
| channel | 带类型的同步队列 | 关闭后仍可接收 |
| context | 取消、超时、请求域值 | 不是全局配置 |
| errgroup | 一组任务的错误汇总与取消 | 不是标准库 |
| worker pool | 固定 worker 消费队列 | 不是无限开 goroutine |
| 背压 | 缓冲满时阻塞生产者 | 不是限流算法 |
| 泄漏 | goroutine 永久阻塞 | 不只是内存泄漏 |
2 机制
2.1 心智模型
异步是发起与等待的分离,不是函数颜色的改变。 调用方用 go 把工作交给新 goroutine 后立即继续;需要结果时从 channel 读,需要放弃时取消 context。goroutine 是任务,channel 是交接点,context 是取消树;调度器提供并发,GOMAXPROCS 决定同时执行的上限。
2.2 机制拆解
- 发起:
go f(ctx)后调用方无法拿到返回值;参数在go语句执行时求值,闭包捕获变量要确认生命周期。 - 结果交接:发送方构造
struct{val T; err error}写入 channel;接收方range或select;channel 由唯一发送方关闭。 - 取消:
WithCancel、WithTimeout、WithDeadline派生取消树;ctx.Done()放进select,返回前检查ctx.Err()。 - 错误汇总:
errgroup.WithContext在首个错误时取消同组任务,Wait返回该错误;Wait只能调用一次。 - 限并发:worker pool 用固定 worker 读 jobs;信号量用
chan struct{};errgroup.SetLimit(n)让Go在满员时阻塞。 - 背压:有界队列满时阻塞生产,或
select default直接拒绝;无界队列把过载变成内存上涨。
2.3 完整枚举
Go 里组织异步的形态,这是完整集合:
| 形态 | 组成 | 适用 | 主要代价 |
|---|---|---|---|
| goroutine + result channel | 一个 goroutine,一个结果 channel | 单次后台任务 | 无人接收时泄漏 |
| WaitGroup | Add、Done、Wait | 只等完成,不传错误 | 无错误传播 |
| errgroup | WithContext、Go、Wait | 一组任务,首个错误取消全组 | 额外依赖,Wait 只能一次 |
| worker pool | 固定 worker 加有界 jobs | 批量任务、限并发 | 关闭协议要设计 |
| pipeline | 多级 channel 串联 | 流式处理、分阶段 | 任一级阻塞会反压全链 |
| fan-out / fan-in | 多 worker 加结果聚合 | 并行请求下游 | 结果顺序要额外维护 |
| 信号量 | 带缓冲 chan struct{} | 限制同时进行的操作 | 获取与释放必须配对 |
| singleflight | 按 key 合并重复调用 | 缓存击穿、重复查询 | 同 key 调用合并为首个结果 |
2.4 关键数字与量级
| 指标 | 量级 | 说明 |
|---|---|---|
| goroutine 初始栈 | 2 KB | 按需增长,不是固定线程栈 |
| 创建 goroutine | 0.3–0.5 µs | 远低于创建 OS 线程 |
| 无竞争 channel 收发 | 50–100 ns | 有竞争时显著上升 |
context.WithCancel | 100–200 ns,2 次分配 | 派生树越深成本越高 |
| 默认 GOMAXPROCS | 逻辑 CPU 数 | 受 cgroup 配额影响 |
| I/O 密集 worker 数 | CPU 的 10–100 倍 | 取决于下游延迟 |
| CPU 密集 worker 数 | 约等于 CPU 数 | 再多只会增加调度开销 |
| 百万 goroutine 内存 | 2–4 GB | 按 2 KB 栈估算 |
-race 开销 | 5–10 倍时间 | 内存同样成倍增加 |
3 实践
3.1 最小示例
示例用 errgroup 启动 4 个任务,SetLimit(2) 限制同时运行数,结果经有缓冲 channel 回收;context 给整组任务设置 1 秒预算,任一任务失败会取消其余任务。
package main
import (
"context"
"fmt"
"time"
"golang.org/x/sync/errgroup"
)
type result struct{ id, value int }
func fetch(ctx context.Context, id int) (int, error) {
select {
case <-time.After(time.Duration(id*5) * time.Millisecond):
return id * id, nil
case <-ctx.Done():
return 0, ctx.Err()
}
}
func main() {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
g, ctx := errgroup.WithContext(ctx)
g.SetLimit(2) // 同时最多 2 个:满员时 Go 阻塞,形成背压
out := make(chan result, 4)
for id := 1; id <= 4; id++ {
id := id // Go 1.22 前必须复制循环变量
g.Go(func() error {
v, err := fetch(ctx, id)
if err != nil {
return err
}
select {
case out <- result{id, v}:
return nil
case <-ctx.Done():
return ctx.Err()
}
})
}
if err := g.Wait(); err != nil {
fmt.Println("failed:", err)
return
}
close(out) // 所有发送者已结束
squares := make([]int, 4)
for r := range out {
squares[r.id-1] = r.value
}
fmt.Println(squares) // [1 4 9 16]
}
追踪:g.SetLimit(2) 让前两个 g.Go 立即启动,后两个在 Go 处阻塞,直到有任务结束,这就是并发上限。errgroup.WithContext 返回的 ctx 在任一任务返回错误或 Wait 返回时取消;fetch 与发送结果都监听 ctx.Done(),所以不会留下阻塞的 goroutine。结果带 id,主 goroutine 按 id-1 写回切片,输出顺序与完成顺序无关。close(out) 放在 Wait 之后,保证没有发送者仍在运行。
3.2 常用操作与参数
| 操作 | 命令 / API | 说明 |
|---|---|---|
| 启动 | go f(ctx) | 无法直接获得返回值 |
| 等待一组 | sync.WaitGroup | Add 必须在 Wait 前 |
| 错误汇总 | errgroup.WithContext | 首个错误取消全组 |
| 限制并发 | errgroup.SetLimit(n) | Go 满员时阻塞 |
| 信号量 | make(chan struct{}, n) | 获取与释放成对 |
| 超时与取消 | context.WithTimeout | 必须调用 cancel |
| 请求级取消 | http.NewRequestWithContext | 不要用 http.Get 丢 ctx |
3.3 标准流程
- 明确结果形态:不需要结果用 WaitGroup;需要首个错误用 errgroup;需要全部错误就收集切片。
- 先画退出路径:每个阻塞操作都要有 context、关闭信号或超时。
- 设并发上限:worker 数按下游容量定,不要按请求数无限开 goroutine。
- 设队列上限:有界 channel 或
SetLimit;满时阻塞或拒绝,不能默默堆积。 - 确定所有权并验证:谁创建 goroutine、谁关闭 channel、谁调用
cancel;用-race、goroutine profile 与超时用例确认没有泄漏和死锁。
3.4 与相邻技术的组合
- net/http 与框架:handler 天然每个请求一个 goroutine;请求内再起的 goroutine 必须用
r.Context()。Gin/Echo 的请求对象在请求结束后失效,需要先把值复制到标准 context。 - database/sql:用
QueryContext、ExecContext;没有 ctx 的查询在请求取消后仍占用连接。 - Errors and Packages:goroutine 内的错误通过 channel 或 errgroup 返回,不要用 panic 跨 goroutine 传播。
- Go Toolchain:
-race、pprof 的 goroutine/block/mutex profile 与go tool trace是同一套诊断入口。
3.5 选型维度
| 方案 | 结果顺序 | 错误处理 | 取消 | 并发上限 | 适用 |
|---|---|---|---|---|---|
| goroutine + channel | 由接收方重组 | 手动传递 | 手动监听 | 无 | 单次后台任务 |
| WaitGroup | 不保证 | 不传播 | 无 | 无 | 只等完成 |
| errgroup | 不保证 | 首个错误 | 自动取消同组 | SetLimit | 一组子任务 |
| worker pool | 按任务自带序号 | 逐任务返回 | 关闭 jobs 加 ctx | 固定 worker | 批量任务 |
| singleflight | 共享首个结果 | 共享首个错误 | 用首个调用者 ctx | 按 key 合并 | 缓存击穿 |
3.6 决策规则
- 只需要“都跑完”用 WaitGroup,需要“任一失败就停”用 errgroup;并发数按数据库连接池、下游 QPS 与内存定。
- 每个 channel 都有明确所有者:谁发送谁关闭,接收方不关闭。
- 结果 channel 至少缓冲 1,或保证接收方在发送方之前就绪。
- 循环里启动 goroutine 时显式复制循环变量,除非模块已声明 Go 1.22 以上。
- 等待一组任务时,先
Wait再关闭结果 channel,避免向已关闭 channel 发送。
3.7 替代方案对比
| 方案 | 优势 | 代价 | 适用 |
|---|---|---|---|
| goroutine + channel | 原语少、控制精细 | 泄漏与死锁要自己防 | 自定义流水线 |
| errgroup | 错误与取消统一 | 额外依赖,只有首个错误 | 请求内并行子任务 |
| worker pool | 并发与队列可控 | 关闭协议复杂 | 消费队列、批量作业 |
| 事件循环(Node) | 单线程无锁 | CPU 密集会阻塞全进程 | I/O 密集服务 |
async/await(JS、Python) | 顺序写法、异常自然 | 需要运行时与函数着色(function coloring) | 单线程异步 I/O 为主 |
3.8 何时不该用
- 任务只有一个且必须立即返回结果:直接同步调用,不要为形式而
go。 - 需要严格顺序的步骤:串行执行,事后排序比并发更难。
- CPU 密集且只有一个核:并发不会加速,只会增加调度与内存。
- 需要跨多个操作保持事务:goroutine 之间没有事务传播,先在单 goroutine 内完成。
4 边界
4.1 典型故障
| 症状 | 根因 | 处理 |
|---|---|---|
| goroutine 数持续上涨 | 阻塞在发送或接收,缺少取消 | 传 context,给 channel 缓冲,确保接收方存在 |
| 程序卡死 | 向无人接收的无缓冲 channel 发送 | 先启动接收方,或缓冲 1,或用 select 超时 |
| 取消失效 | 下游忽略 context,或用了 context.Background() | 逐层传递 r.Context(),I/O 用带 ctx 的 API |
| 结果错位或重复 | 闭包捕获循环变量,或共享切片无同步 | 复制循环变量,结果带 id 并由单 goroutine 写回 |
send on closed channel / close of closed channel | 多个发送方都尝试关闭,或关闭执行两次 | 只让唯一所有者关闭,必要时用 sync.Once |
| WaitGroup 提前返回 | Add 与 Wait 并发,或 Add 在 Wait 后 | 在启动 goroutine 前 Add |
| 内存持续上涨 | 无界队列或 goroutine 无限创建 | 有界队列、worker pool、拒绝策略 |
4.2 反模式
| 做法 | 后果 | 替代 |
|---|---|---|
每个请求 go 一个无上限任务 | 过载时 OOM 与延迟爆炸 | worker pool 加有界队列 |
用 time.Sleep 等结果 | 不确定、测试变慢 | WaitGroup 或 channel |
在循环里 time.After | 每次分配定时器,泄漏到触发 | time.NewTimer 加 Stop |
4.3 可观测信号
runtime.NumGoroutine() 的长期趋势、pprof goroutine 栈中同一函数的堆积量、block profile 的阻塞时长、mutex profile 的竞争、ctx.Err() 的分类计数、队列深度与入队等待时间、请求 P99 与超时率、go test -race 报告。先看 goroutine 栈定位阻塞点,再看队列与下游延迟,最后判断是泄漏还是过载。
4.4 安全 / 性能 / 一致性边界
- 取消边界:取消是协作式的;不检查
ctx.Done()的代码无法被取消,也不会被强制终止。 - 生命周期边界:goroutine 没有父子关系,父 goroutine 退出不会杀子;任何未回收的 goroutine 都占着栈和它引用的对象。
- panic 边界:一个 goroutine 内未恢复的 panic 会终止整个进程;
recover只能捕获同一 goroutine 的 panic。 - 并行边界:goroutine 提供并发,不自动提供并行;CPU 密集任务受
GOMAXPROCS限制,I/O 密集任务受下游容量与内存限制。