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 会因上下文结束而返回。

go
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)))
}

预期输出

text
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 当成控制流信号,而不是继续执行昂贵工作后再尝试写响应。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

传播取消与截止时间

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通