一个后台任务最近越来越慢。它每次执行都会创建几个带超时的子任务,超时时间从几分钟到十几分钟不等。代码看起来没问题:每个超时都有 context.WithTimeout,每个子任务也都检查了 ctx.Done()。但进程的内存曲线一直向上,pprof 显示大量定时器没有释放。

问题不在超时本身,而在 cancel 函数:代码创建了带超时的 context,却从来没有调用对应的 cancel。即使超时时间到了、context 已经被取消,关联的定时器和其他资源仍然要等到 cancel 被调用才能释放。这个小疏忽在短生命周期请求里看不出来,放到常驻的后台任务里,就是持续累积。

这篇讲 context 的使用方式,以及它和调度、并发控制、服务退出之间的关系。重点不是把接口方法列一遍,而是说清楚「什么时候该取消」「怎么把取消传到下游」「为什么加了超时还是会卡住」「优雅退出到底在等什么」。

cancel 没调用,泄漏的不只是内存

先看一个会被静态检查抓到的写法。函数在一条路径上创建了 context,却在另一条路径直接返回,没有调用 cancel:

func start(ok bool) context.Context {
	ctx, cancel := context.WithCancel(context.Background())
	if ok {
		cancel()
		return context.Background()
	}
	return ctx
}

本机 go1.27.3 执行 go vet main.go,实际输出:

main.go:9:2: the cancel function is not used on all paths (possible context leak)
main.go:14:2: this return statement may be reached without using the cancel var defined on line 9

vet 的第二行已经把问题说清楚了:这条 return 路径上,cancel 没有被调用。运行时后果是,即使父 context 后来被取消、即使超时时间到了,这个 context 关联的定时器和内部结构仍可能保留,直到 cancel 被调用。单个请求结束后进程就回收了,问题不明显;常驻服务里,这就是一条缓慢上升的曲线。

正确习惯是「谁创建,谁负责取消」:ctx, cancel := context.WithCancel(...) 之后立刻 defer cancel(),除非这个 context 要交给别人负责。带超时的版本也一样,WithTimeout 返回的 cancel 不是可选的,它负责释放定时器。

defer cancel() 不会让已经在执行的下游立刻停下,它只是关闭 Done channel 并释放资源。下游必须自己检查 ctx.Done() 或把 context 传给支持取消的 API,取消才会真正生效。只 cancel 不检查,等于发了通知没人看。

context 的四件事,以及它不做什么

context.Context 是一个接口,提供四个能力:Deadline 返回截止时间,Done 返回一个在取消时关闭的 channel,Err 返回取消原因,Value 按键取值。它的典型用途是四件事:传递取消信号、传递截止时间、在调用链中共享请求级数据、把多个 goroutine 组织成一棵可以整体取消的树。

取消是向下传播的。父 context 被取消,所有由它派生出来的子 context 都会关闭 Done;子 context 被取消,父 context 不受影响。这个方向很重要:一个请求派生多个下游调用,任意一个超时可以只影响它自己,而上层请求超时应该让所有下游一起停。

context 不负责「杀死 goroutine」。Go 没有强制终止某个 goroutine 的 API,取消只是一种协作机制:goroutine 必须自己检查 Done,或者在阻塞调用上使用支持 context 的版本。一个死循环里不检查 ctx 的 goroutine,调用 cancel 之后仍然会跑完,甚至永远跑不完。

根context.Background() 或 context.TODO()。没有截止时间,也不会被取消,通常作为整棵树的起点。
派生WithCancel、WithTimeout、WithDeadline、WithValue 都基于父 context 创建子节点,取消沿父子关系向下传播。
叶子具体的网络请求、数据库查询、子 goroutine。它们检查 Done 或把 context 交给底层 API,取消最终在这里生效。

有两个常见误解。第一,context.TODO() 不是「空实现」的占位符,它和 Background 一样可用,只是表达「这里以后会换成真正的 context」。第二,context 不是依赖注入容器。往里塞数据库连接、配置对象、日志器,会让调用关系变得隐式,测试也难替换。它只适合放「一次请求内有效、不可变、并发安全」的小数据,比如请求 ID、用户身份。

说到调度,context 的取消能生效,前提是 goroutine 有机会运行到检查点。Go 的调度器把 goroutine 映射到有限的 OS 线程上,GOMAXPROCS 决定同时执行的数量。本机 runtime.NumCPU() 和 GOMAXPROCS(0) 都返回 12。一个纯计算、不检查 ctx 的循环会一直占着 P,直到时间片被抢占;从 Go 1.14 起运行时支持异步抢占,长循环不会永久霸占 CPU,但这只是保证「别的 goroutine 能跑」,不保证「你的循环会主动退出」。取消仍然要靠代码配合。

超时:WithTimeout 和 WithDeadline 的区别

两个函数都返回带截止时间的 context,区别在时间基准。WithTimeout 是「从现在起多少时间后截止」,WithDeadline 是「到某个绝对时刻截止」。处理一个已经带截止时间的上游请求时,用 WithDeadline 更准确:如果你用 Timeout 重新计时,每一层都加一段,最外层说 3 秒,到了第五层可能已经过了 10 秒。

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

select {
case <-ctx.Done():
	fmt.Println("结束原因:", ctx.Err())
case result := <-work:
	fmt.Println("拿到结果:", result)
}

取消原因有两个常见值:context.Canceled 表示被主动取消,context.DeadlineExceeded 表示超时。判断时要看 ctx.Err(),不要解析错误文本。下游返回的错误可能被包装成别的形式,甚至被替换成「连接关闭」,但 context 的原因始终在 ctx 上。

超时不等于「下游已经停止」。context 只是通知,网络库可能在收到通知后关闭连接,也可能因为正处于不可中断的系统调用而晚一点返回。设置超时的意义是「调用方不再无限等待」,不是「对方一定在那一刻停下」。真正要限制对方资源,需要服务端自己也设超时。

还有一个细节:WithTimeout 的定时器在 cancel 被调用时释放。如果你只等 Done 关闭、不调用 cancel,定时器可能留到截止时间才清理。短超时无所谓,长超时加上高并发就会积累。所以无论超时还是主动取消,defer cancel 都别省。

传递规范:第一个参数,不放进结构体

Go 的惯例是把 context 作为函数的第一个参数,命名 ctx,并且不把它存进结构体、不放在可选参数里。这样做的好处是调用链上每一层都明确知道「这次调用受哪个取消信号控制」,读代码时也能一眼看到传播路径。

func loadUser(ctx context.Context, id int) (*User, error) {
	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
	if err != nil {
		return nil, err
	}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	// ...
}

把 context 放进结构体,常见于「对象初始化时保存一个 ctx,之后所有方法都用它」。问题是这个 ctx 的生命周期和对象一样长,无法按请求取消;多个请求共用同一个对象时,一个请求取消会影响其他请求。确实需要保存的场景很少,通常出现在框架内部,业务代码不要模仿。

也不要传 nil。需要占位时用 context.TODO(),它的行为和 Background 一样,但语义上明确表示「还没接上真正的 context」,便于后续搜索和替换。传 nil 会在下游调用 ctx.Done() 时直接 panic,而且错误位置离源头很远。

在 goroutine 里使用 context,要注意它是并发安全的,可以被多个 goroutine 同时读取;但 Value 里存的对象必须是不可变的,或者由调用方保证并发安全。往 context 里塞一个普通 map,然后多个 goroutine 同时改,等于把数据竞争藏进了调用链。

HTTP 链路:客户端断开只是开始

服务端的 r.Context() 在客户端断开连接时会被取消。这意味着一个耗时的 Handler 如果只关心自己的计算,不检查 r.Context().Done(),客户端早就走了,它还在占用 CPU 和下游连接。把 r.Context() 传给数据库查询、下游 HTTP 请求,是让整条链路一起停下来的关键。

客户端侧,http.NewRequestWithContext 把 context 和请求绑定;context 取消时,正在进行的连接会被中断。只设 Client.Timeout 也能限制总时长,但它是「到点就放弃」,无法响应上游的提前取消。两层都设是常见做法:Client.Timeout 作为兜底,context 负责传播上游的取消意图。

超时预算要在链路上分配。入口给整个请求 3 秒,调用下游 A 最多 1 秒,调用下游 B 最多 1.5 秒,剩下的留给自己的处理。如果每一层都写「超时 3 秒」,最坏情况下总耗时可能是各层相加,用户早就走了。用 WithDeadline 继承上游的绝对截止时间,能避免这种层层加码。

还要注意:客户端取消请求,不代表服务端的下游调用会自动取消。只有当服务端把 r.Context() 一路传下去,下游的 HTTP 客户端、数据库驱动才会收到取消信号。中间任何一层用了 context.Background(),链路就在那里断开了。

限流:信号量 + context,避免无限排队

第 7 篇的 worker 池控制了 worker 数量,但如果任务是「每个请求一个 goroutine」,还需要另一层限制:同时进行的下游调用不能超过某个数量。最简单的实现是一个带缓冲的 channel 当信号量。

sem := make(chan struct{}, 3)
var cur, max int32

for i := 0; i < 10; i++ {
	wg.Add(1)
	go func(id int) {
		defer wg.Done()
		sem <- struct{}{}
		defer func() { <-sem }()
		n := atomic.AddInt32(&cur, 1)
		// 更新 max
		time.Sleep(200 * time.Millisecond)
		atomic.AddInt32(&cur, -1)
	}(i)
}
wg.Wait()

本机实际输出:

NumCPU: 12 GOMAXPROCS: 12
最大同时执行数: 3

十个任务,最多只有三个同时执行,符合预期。但这个版本有一个问题:等待信号量的 goroutine 不响应取消。如果请求已经超时,它们还排在 channel 上,等轮到自己才发现没人要结果。改进方式是把获取信号量也放进 select:

select {
case sem <- struct{}{}:
	defer func() { <-sem }()
case <-ctx.Done():
	return ctx.Err()
}

这样排队也能被取消,队列不会越积越长。限流的目标不是「挡住请求」,而是「让等待有上限」。只限制并发数、不限制等待时间,高流量下会积累大量半死的 goroutine,内存和延迟都会恶化。

限流阈值要和下游容量匹配。数据库连接池 20 个连接,业务层限流 100,多出来的 80 个只会在池子门口排队;反过来,限流 5 而连接池 20,又浪费了容量。阈值应该由下游的真实承载能力和压测结果决定,不是拍一个整数。

优雅退出:Shutdown 到底在等什么

服务收到退出信号时,直接 os.Exit 会切断正在处理的请求。优雅退出分三步:停止接收新请求、等待在途请求结束、释放资源。标准库的 Server.Shutdown 负责前两步,第三步要自己按依赖顺序做。

本机用 httptest 之外的真实监听方式验证:一个 Handler 睡 300 毫秒,客户端在 150 毫秒时发起请求,主 goroutine 在 150 毫秒时调用 Shutdown。实际输出顺序是:

服务监听: 127.0.0.1:33607
  处理器开始
开始 Shutdown
  处理器结束
客户端收到响应
Shutdown 返回: <nil>

可以看到,Shutdown 调用之后并没有立刻返回,而是等处理器写完响应、客户端收到数据,才返回 nil。这正是「优雅」的含义:新连接被拒绝,老请求被允许完成。如果给 Shutdown 的 context 设了 2 秒超时,而某个请求一直不结束,Shutdown 会返回 context.DeadlineExceeded,剩下的请求不再等待。

完整流程通常是:监听 os.Interrupt 和 SIGTERM,收到后创建一个带超时的 context,调用 srv.Shutdown(ctx);Shutdown 返回后再关闭数据库连接、消息队列、日志缓冲。顺序不能反:先关数据库,正在处理的请求会全部失败。

signal.NotifyContext 可以把信号监听和 context 合并,代码更短。但要注意它只在 Unix 上对 SIGTERM 有效,Windows 的控制台事件是另一套机制,第 6 篇已经讲过。部署在哪个平台,就在哪个平台上验证退出流程,不能只在开发机上按 Ctrl+C 试一次。

还有一种情况 Shutdown 管不了:长连接、WebSocket、正在上传的大文件。它们可能一直占着连接,Shutdown 会等到超时才返回。这类服务需要自己记录活跃连接,在退出时主动通知对方,或者接受「超时后强制关闭」的代价。

出问题时先看哪里

现象真实原因第一步查什么
内存和定时器持续增长创建了 context 却没调用 cancel跑 go vet 看 lostcancel;确认每个 With 系列都有 defer cancel
加了超时,调用还是卡很久下游函数不检查 ctx,或用了 Background 断开链路看调用链每层是否都接收并传递 ctx;阻塞调用是否支持 context
ctx 报 canceled,但任务还在跑取消是协作式的,代码没有检查 Done在循环和耗时操作前加检查;把 ctx 交给底层 API
客户端断开后服务端仍在计算没有使用 r.Context()看 Handler 是否把请求 context 传给下游
请求总耗时超过入口超时每层都重新计时,超时预算叠加改用 WithDeadline 继承绝对截止时间;给每段分配预算
限流队列越来越长等待信号量不可取消,请求超时后仍在排队把获取信号量放进 select,监听 ctx.Done()
Shutdown 一直不返回有长连接或在途请求不结束给 Shutdown 设超时;检查 WebSocket、上传、长轮询
退出后请求全部失败先关了数据库或下游,再停止接收请求调整关闭顺序:先 Shutdown,再释放依赖
Windows 上收不到 SIGTERM平台不支持该信号语义改用 Ctrl+C 或平台服务管理机制;按部署平台验证

排查取消问题,先确认三件事:context 有没有一路传下去、每一层有没有检查、底层的阻塞调用是否支持 context。三者缺一,取消就不会生效。很多「超时无效」的案例,最后都发现中间某层用了 context.Background(),把链路悄悄剪断了。

边界与代价

  • 取消不是强杀:goroutine 必须配合检查,纯计算循环不会因为 ctx 取消而自动退出。Go 没有提供安全的强制终止手段,这是设计选择。
  • context 会让签名变长:几乎每个函数都多一个参数,初级代码看起来啰嗦。换来的是取消路径显式、可追踪,不用靠全局变量或隐藏状态。
  • Value 是弱类型:取值后要类型断言,键类型用错会拿不到值,甚至 panic。只放少量请求级数据,并且把键定义成非导出的自定义类型,避免不同包撞键。
  • 超时预算需要设计:每层都设超时,不等于总时长可控。没有统一的截止时间,层层叠加会让入口的承诺失效。
  • Shutdown 只负责 HTTP 连接:后台 goroutine、消息消费、定时任务不会被它自动停止,需要自己用 context 通知并等待。
  • 调度器不解决阻塞:GOMAXPROCS 决定并行执行的数量,不决定阻塞调用何时返回。网络、磁盘、锁上的等待,仍然要靠超时和取消来兜底。

context 的价值在于把「这次工作还要不要继续」变成调用链上的显式参数。它不隐藏任何东西,也不自动解决并发问题,但让每一层都有机会在合适的时候停下来。配合第 7 篇的 goroutine 所有权、第 6 篇的进程取消,一套完整的生命周期管理才闭合。

当天能自己验证的练习

  1. 写一个在部分路径漏掉 cancel 的函数,运行 go vet,确认出现 lostcancel 的两行提示;改成 defer cancel() 后复测。
  2. 用 WithTimeout 创建一个 100 毫秒的 context,在 select 里等 ctx.Done(),打印 ctx.Err(),确认是 context.DeadlineExceeded。
  3. 把一个带 2 秒超时的 context 传给一个故意 sleep 5 秒的函数,观察函数不会被打断、仍然睡完;再在函数里加 select 检查 Done,确认能提前返回。
  4. 用带缓冲 channel 实现并发上限 3 的信号量,跑十个任务并统计最大同时执行数;再把获取信号量改成 select 监听 ctx,观察取消时排队的任务能退出。
  5. 启动一个真实 HTTP 服务,Handler 睡 300 毫秒,在主流程调用带超时的 Shutdown,打印调用顺序,确认 Shutdown 等到了在途请求结束。

小结

三句话收一下:context 是一棵向下传播的取消树,创建就要负责 cancel,否则定时器和资源会泄漏;取消是协作式的,调用链每一层都要传 ctx、检查 Done,任何一层换成 Background 都会让超时失效;优雅退出要先停止接收新请求、再等在途请求、最后释放依赖,Shutdown 只覆盖 HTTP 连接,别的后台任务要自己停。

到这里,Go 组的八篇走完了一遍:从语法和类型,到 defer、goroutine、错误处理,再到标准库、文件、网络、子进程、并发和取消。这些内容不会让你立刻写出完美的服务,但能让你在看栈、看竞态报告、看超时日志时,知道每一层在发生什么。下一步建议挑一个自己项目里的小工具,用这八篇里的检查项过一遍,比继续读更多概念更有用。