Go / 系统课时
传播取消与截止时间
传播取消与截止时间
HTTP 请求结束后继续做数据库查询或下游调用,会白白占用连接、CPU 和并发额度。本篇用 Request.Context 建立超时边界,把同一个取消信号传给下游请求,并验证截止时间到达后处理器会停止等待而不是把工作留在后台。
学习目标
- 从
Request.Context获取请求生命周期,并在服务端建立明确的截止时间。 - 把上下文传给支持
Context的数据库或下游 HTTP API。 - 区分取消与超时,并避免脱离请求上下文启动无约束后台工作。
请求上下文负责传递停止信号
r.Context() 会在请求生命周期结束时提供取消信号,例如客户端连接断开或上层代码显式取消。业务代码应继续把这个上下文传给 QueryContext、ExecContext、NewRequestWithContext 等支持取消的 API,而不是换成 context.Background()。
服务端的业务超时通常需要自己建立。context.WithTimeout 返回的子上下文会继承父上下文的取消:客户端先断开时立即取消;业务截止时间先到时则得到 context.DeadlineExceeded。无论哪种情况,都应该调用返回的 cancel 释放相关资源。

用超时中间件贯穿下游调用
下面的完整程序让下游服务故意等待 300 毫秒,而上层只给请求 80 毫秒预算。超时中间件把带截止时间的上下文写回请求,处理器再用它创建下游请求;一旦截止时间到达,Do 会因上下文结束而返回。
package main
import (
"context"
"fmt"
"io"
"net/http"
"net/http/httptest"
"strings"
"time"
)
func withTimeout(next http.Handler, timeout time.Duration) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), timeout)
defer cancel()
// 后续处理器统一从 Request.Context 获取同一条生命周期信号。
next.ServeHTTP(w, r.WithContext(ctx))
})
}
func proxyHandler(downstreamURL string) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
req, err := http.NewRequestWithContext(
ctx, http.MethodGet, downstreamURL, nil,
)
if err != nil {
http.Error(w, "build request failed", http.StatusInternalServerError)
return
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
switch ctx.Err() {
case context.DeadlineExceeded:
fmt.Println("handler: deadline exceeded")
http.Error(w, "upstream timeout", http.StatusGatewayTimeout)
case context.Canceled:
fmt.Println("handler: request canceled")
default:
http.Error(w, "upstream failed", http.StatusBadGateway)
}
return
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
http.Error(w, "read upstream failed", http.StatusBadGateway)
return
}
w.Write(body)
})
}
func main() {
downstream := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
select {
case <-time.After(300 * time.Millisecond):
fmt.Fprintln(w, "slow result")
case <-r.Context().Done():
// 上游取消后立即结束,不继续占用处理 goroutine。
return
}
},
))
defer downstream.Close()
app := httptest.NewServer(
withTimeout(proxyHandler(downstream.URL), 80*time.Millisecond),
)
defer app.Close()
resp, err := http.Get(app.URL)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
panic(err)
}
fmt.Printf("client: status=%d body=%q\n",
resp.StatusCode, strings.TrimSpace(string(body)))
}预期输出
handler: deadline exceeded
client: status=504 body="upstream timeout"这里的 80 毫秒和 300 毫秒都是示例预算,实际服务应按接口 SLO、下游预算和重试策略确定。关键不是某个固定数字,而是让所有阻塞操作都观察同一条上下文链;否则最外层虽然超时返回,内部工作仍可能继续消耗资源。
数据库与其他调用遵循同一原则
数据库操作应优先使用 db.QueryContext(ctx, ...)、db.ExecContext(ctx, ...) 或事务内对应的 Context API。驱动是否能立刻中止服务器端工作取决于具体实现,但调用方至少会有一致的取消边界,连接也能更快回到可复用状态。
不要为了“让任务跑完”把请求上下文替换成 context.Background() 再启动 goroutine。确实需要异步任务时,应先把任务写入队列或持久化任务表,再由拥有独立生命周期、超时和重试策略的 worker 处理;请求 goroutine 只负责可靠提交任务。
截止时间不会自动跨 HTTP 序列化
把 ctx 绑定到出站 http.Request,可以让本地 HTTP 客户端在取消或超时时停止等待,并通过连接终止让远端感知请求结束;但 context.Context 本身不会被编码进 HTTP 请求,deadline 的具体时间也不会自动变成请求头。
如果跨服务协议要求共享剩余预算,需要显式设计并校验对应的协议字段,再在接收端创建新的本地上下文。无论采用哪种协议,处理器都应把 context.Canceled 与 context.DeadlineExceeded 当成控制流信号,而不是继续执行昂贵工作后再尝试写响应。