🚀客户端都超时了,你的 Go 服务还在查库?Context 取消链路不打通,连接池迟早被打爆

一个列表接口压测时表现正常,上线后却开始出现异常:

  • 客户端请求超时,已经断开连接
  • 服务端还在继续查库、拼装数据
  • 数据库连接池被大量无效请求占满
  • 正常请求开始排队,接口延迟持续升高

排查后发现:Handler 确实写了 context.WithTimeout,设置了 2 秒超时,但 Service 没接收 context,Repository 没用 WithContext,HTTP 调用也没绑定请求上下文。

看起来每层都做了一点超时,实际上取消信号根本没传到真正执行 IO 的地方。

客户端已经不需要结果了,服务端却还在消耗数据库连接、CPU 和下游资源。这不是超时配置问题,而是请求生命周期没有打通。

本文只解决一件事:

客户端取消或请求超时后,如何让取消信号从 Gin Handler 一路传到 Service、GORM Repository 和 HTTP Client,及时停止不再需要的工作。

为什么你设置了超时,服务端还是停不下来?

先看一个典型的详情接口:

复制代码
客户端
  ↓
Gin Handler
  ↓
ConversationService.GetByID
  ├── ConversationRepo.Find
  └── UserCenterClient.Verify

一次请求可能涉及数据库查询、下游 HTTP 调用和本地数据组装。

理想情况下,客户端断开后应该是:

arduino 复制代码
客户端断开
  ↓
c.Request.Context() 取消
  ↓
Handler 感知取消
  ↓
Service 停止后续业务
  ↓
Repository / HTTP Client 中断可取消的 IO

但很多项目实际是断的。

问题 1:Service 根本没接收 context

最初的代码可能是:

go 复制代码
// 错误:Service 不接收 ctx,下游无法感知请求是否取消。
func (s *ConversationService) GetByID(
    userID string,
    id uint64,
) (*Conversation, error) {
    // 查询数据库,但没有请求上下文。
    conv, err := s.repo.Find(id)
    if err != nil {
        return nil, err
    }

    // 调用用户中心,同样无法感知客户端取消。
    user, err := s.users.Verify(userID)
    if err != nil {
        return nil, err
    }

    conv.UserName = user.Name
    return conv, nil
}

Service 不接收 context.Context,下游自然无法知道当前请求是否已经取消。

即使客户端断开,业务代码仍然会继续执行。

问题 2:Handler 创建了超时,却没传下去

go 复制代码
func (h *Handler) GetConversation(c *gin.Context) {
    // 创建 2 秒超时的上下文。
    ctx, cancel := context.WithTimeout(
        c.Request.Context(),
        2*time.Second,
    )
    defer cancel()

    // 错误:创建了 ctx,却没有传给 Service。
    conv, err := h.svc.GetByID(userID, id)
    _ = ctx

    if err != nil {
        handleServiceError(c, err)
        return
    }

    response.OK(c, conv)
}

这段代码看起来已经有超时了,但实际上:

  1. Handler:知道请求超时
  2. Service:不知道
  3. Repository:不知道
  4. HTTP Client:不知道

context.WithTimeout 只是创建了带截止时间的上下文。不传给下游,超时信号就只能停在 Handler。

问题 3:Repository 收了 ctx,但数据库查询没用它

有些代码已经修改了函数签名:

go 复制代码
func (r *ConversationRepo) Find(
    ctx context.Context,
    id uint64,
) (*Conversation, error) {
    var conv Conversation

    // 错误:接收了 ctx,但查询没有绑定它。
    err := r.db.First(&conv, id).Error

    return &conv, err
}

这只是函数签名支持 context,并没有让数据库操作具备取消能力。正确做法是:

go 复制代码
// 使用 GORM 的 `WithContext`
r.db.WithContext(ctx).First(&conv, id)

问题 4:HTTP 请求还在用 http.NewRequest

数据库查询改好了,HTTP 调用却可能还是:

go 复制代码
// 错误:请求没有绑定 context,无法随请求取消。
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
    return nil, err
}

resp, err := client.Do(req)

这种请求无法通过当前请求的 context 主动取消。应该改成:

go 复制代码
// 正确:把请求上下文绑定到 HTTP 请求。
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)

这些问题单独看都不复杂,组合起来就是:接口虽然超时返回了,后台工作却可能还在继续跑。

🚀正确目标:Context 从 Gin Handler 一路传到 IO

各层职责先明确:

层级 主要职责
Gin Handler 继承请求 context,设置 API 总超时
Service 接收并向下传递 context,必要时检查取消状态
Repository 用 GORM WithContext 让数据库感知取消
HTTP Client 用 NewRequestWithContext 让下游请求感知取消

完整链路:

text 复制代码
  客户端断开 / 服务端超时
          ↓
c.Request.Context() / context.WithTimeout
          ↓
      Gin Handler
          ↓
       Service
          ↓
  ┌───────┴────────┐
  ↓                ↓
GORM              HTTP Client
WithContext       NewRequestWithContext
  ↓                ↓
数据库查询取消     下游请求取消

Gin Handler:继承客户端取消,同时设置服务端超时

go 复制代码
func (h *Handler) GetConversation(c *gin.Context) {
    // c.Request.Context() 代表当前 HTTP 请求的生命周期。
    // 当客户端断开连接、HTTP/2 请求取消时,该 context 会被取消。
    //
    // 再叠加 2 秒服务端超时,避免请求无限期占用资源。
    ctx, cancel := context.WithTimeout(
        c.Request.Context(),
        2*time.Second,
    )
    // 及时释放定时器等相关资源。
    defer cancel()

    userID := c.GetString("user_id")

    id, err := strconv.ParseUint(c.Param("id"), 10, 64)
    if err != nil {
        response.Error(c, ErrInvalidParams)
        return
    }

    // 关键:把同一个请求 ctx 继续传给 Service。
    // 不要在这里重新创建 context.Background()。
    conv, err := h.svc.GetByID(ctx, userID, id)
    if err != nil {
        handleServiceError(c, err)
        return
    }

    response.OK(c, conv)
}

这里有两个关键点:

  1. 用 c.Request.Context() 继承客户端取消信号。
  2. 再用 context.WithTimeout 加服务端总期限。 客户端不一定设置合理超时,服务端必须保护自己。

两种取消来源会汇合到同一个 ctx:

  • 客户端提前断开 → Request.Context 取消
  • 服务端达到 2 秒 → WithTimeout 派生的 ctx 取消

下游只需要认这一个 ctx。

Service:传递 context,并在后续操作前检查取消

go 复制代码
func (s *ConversationService) GetByID(
    ctx context.Context,
    userID string,
    id uint64,
) (*Conversation, error) {
    // 数据库查询继续使用请求 ctx。
    conv, err := s.repo.Find(ctx, id)
    if err != nil {
        return nil, fmt.Errorf("find conversation: %w", err)
    }

    if conv == nil {
        return nil, ErrNotFound
    }

    // 校验会话归属。
    if conv.UserID != userID {
        return nil, ErrForbidden
    }

    // context 取消不会自动终止普通 Go 代码。
    // 如果前面的操作已经耗时较长,这里要主动检查取消状态,
    // 避免请求已经取消后还继续启动下游调用。
    if err := ctx.Err(); err != nil {
        return nil, err
    }

    // 为用户中心调用设置独立的 500ms 超时。
    // 子 ctx 继承父 ctx:父请求取消时,userCtx 也会取消。
    userCtx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
    defer cancel()

    // 继续向下游传递同一个请求生命周期。
    user, err := s.users.Verify(userCtx, userID)
    if err != nil {
        return nil, fmt.Errorf("verify user: %w", err)
    }

    conv.UserName = user.Name
    return conv, nil
}

注意:Service 不要随手写这种代码:

go 复制代码
// 错误:切断了请求生命周期。
user, err := s.users.Verify(context.Background(), userID)

// 正确:继续传递当前请求上下文。
user, err := s.users.Verify(ctx, userID)

另外,context 取消不会自动终止普通 Go 代码。如果 Service 里有复杂循环、数据组装,需要主动检查:

go 复制代码
for _, item := range items {
    // 每轮处理前检查请求是否已经取消。
    if err := ctx.Err(); err != nil {
        return nil, err
    }

    process(item)
}

对于不支持 context 的阻塞函数,单纯传 context 也无法强制终止它。

Repository:GORM 必须用 WithContext

go 复制代码
func (r *ConversationRepo) Find(
    ctx context.Context,
    id uint64,
) (*Conversation, error) {
    var conv Conversation

    // 关键:WithContext 会把请求 ctx 绑定到本次 GORM 查询。
    // ctx 取消或超时时,取消信号会传递给底层数据库操作。
    err := r.db.WithContext(ctx).First(&conv, id).Error

    // 区分"记录不存在"和其他数据库错误。
    if errors.Is(err, gorm.ErrRecordNotFound) {
        return nil, nil
    }

    if err != nil {
        return nil, fmt.Errorf(
            "query conversation id=%d: %w",
            id,
            err,
        )
    }

    return &conv, nil
}

这里最关键的是:

scss 复制代码
r.db.WithContext(ctx)

它会将 context 关联到后续的 GORM 操作。

但需要明确一个边界:传入 context 不等于所有数据库查询都能瞬间停止。

实际取消能力还取决于底层数据库驱动是否支持取消,以及数据库端是否能及时终止正在执行的语句。因此,生产环境仍应配置数据库连接和查询超时,不能只依赖请求 context。

HTTP Client:用 NewRequestWithContext 取消下游请求

go 复制代码
func (c *Client) Verify(
    ctx context.Context,
    token string,
) (*UserInfo, error) {
    // 关键:把当前请求 ctx 绑定到 HTTP 请求。
    // ctx 取消时,本次下游 HTTP 请求也会被取消。
    req, err := http.NewRequestWithContext(
        ctx,
        http.MethodGet,
        c.verifyURL,
        nil,
    )
    if err != nil {
        return nil, fmt.Errorf(
            "usercenter: create request failed: %w",
            err,
        )
    }

    // 设置认证信息。
    req.Header.Set("Authorization", "Bearer "+token)

    // http.Client 应该复用,不要每次请求都 new 一个。
    resp, err := c.httpClient.Do(req)
    if err != nil {
        // 取消或超时时,可通过错误链识别 context 错误。
        return nil, fmt.Errorf(
            "usercenter: request failed: %w",
            err,
        )
    }
    // 响应体必须及时关闭,避免连接资源无法复用。
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf(
            "usercenter: unexpected status code: %d",
            resp.StatusCode,
        )
    }

    return parseUserInfo(resp.Body)
}

两个实践细节:

  • http.Client 要复用,不要每次请求创建新 Client。
  • 响应体必须及时关闭。

超时应该设在哪里?不要每一层都随手 WithTimeout

很多项目完成 context 穿透后,又开始在每一层设置超时:

go 复制代码
Handler:2 秒
Service:3 秒
Repository:5 秒
HTTP Client:10 秒

看起来很安全,实际很难判断整个请求的真实截止时间。

更合理的是区分两类超时:

类型 作用 建议位置
API 总超时 限制一次请求的整体处理时间 Handler / Middleware
下游调用超时 限制单次数据库或 HTTP 调用 对应 IO 调用层

例如:API 总超时 2 秒,用户中心最多允许占用 500ms:

go 复制代码
// 为下游用户中心设置独立 500ms 超时。
// 它继承父 ctx,父请求取消时它也会取消。
userCtx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
defer cancel()

user, err := s.users.Verify(userCtx, userID)

注意:

  • 子 context 的截止时间不会晚于父 context。
  • 父 context 提前取消,子 context 也会取消。
  • 子 context 自己超时,不会反过来取消父 context。
  • cancel() 应通过 defer 及时调用。

超时策略的重点不是每层随手写个数字,而是明确:谁负责总期限,谁负责单次调用期限。

上线后重点看什么?不要只看接口超时率

Context 改造上线后,建议重点观察:

指标 观察什么
API P95 / P99 请求延迟是否改善
数据库连接池使用率 无效请求是否减少
请求取消和超时比例 取消是否频繁发生
下游请求耗时与取消情况 是否存在无法及时结束的调用

尤其关注数据库连接池。

如果客户端大量取消请求,但连接池使用率仍持续偏高,要继续排查:

  • SQL 是否真正绑定了请求 context;
  • 数据库驱动是否支持取消;
  • 是否有不受 context 控制的阻塞调用;
  • 是否有 goroutine 在请求结束后继续执行;
  • 是否存在独立于请求生命周期的后台任务。

另外,取消并不意味着数据库一定已经完成回滚,也不意味着所有副作用都能撤销。写操作还要结合事务、幂等性和业务补偿处理。

小结:Context 真正重要的是打通请求生命周期

一次 context 改造,真正交付的不是函数签名多了一个 context.Context,而是让取消信号穿透整条调用链。

可以归纳为四步:

  1. 先定位断点。 取消后还在查库、调下游,还是继续本地计算?
  2. 打通传递链路。 Gin Handler 创建或继承 ctx,Service 负责向下传递。
  3. 让 IO 真正响应取消。 GORM 用 WithContext,HTTP 用 NewRequestWithContext。
  4. 上线看连接池和取消比例。 不要只看接口是否返回超时。

最后记住三个概念:

  • WithCancel:主动取消任务。
  • WithTimeout:设置最大执行时间。
  • WithDeadline:设置明确截止时间。

Go 的 context 真正难的不是会不会写 WithTimeout,而是请求经过十层调用、接入多个下游服务后,你仍然知道取消信号从哪里来、传到了哪里,以及哪些工作真正能停止。

客户端已经不需要的结果,就不要再让服务端继续为它消耗资源。

你认为呢?欢迎在评论区一起讨论!也希望这篇文章对你有所帮助、有所借鉴。

相关推荐
拖孩23 分钟前
# 我又用 AI 做了个小程序:24 天,记录我这辈子认识的人
前端·后端·微信小程序
Csvn32 分钟前
Nginx rewrite 与 server_name:last/break 语义、多域名匹配与伪静态
后端·nginx
Baihai_IDP1 小时前
使用场景不同,模型“推理速度慢”的原因也不同
人工智能·面试·llm
AAA修煤气灶刘哥1 小时前
32 GB 内存跑起 1800 亿参数模型,代价是什么?
人工智能·后端·架构
SimonKing1 小时前
零 OCR 依赖!Firecrawl 这个 Rust 库把 Word / PPT / Excel 全变成 Markdown
java·后端·程序员
Rain的Java大神之路1 小时前
别被 ChatGPT 的打字机效果骗了:一字一字蹦,才是 LLM 自回归的命门(附大厂 Java 流式落地)
java·后端·面试
AAA修煤气灶刘哥1 小时前
同一个项目,为什么换个 Agent 又得从头解释?
后端·架构·代码规范
BingoGo2 小时前
PHP 8.6 正式发布
后端·php
JaguarJack2 小时前
PHP 8.6 正式发布
后端·php·服务端