Go语言Context.WithTimeout在级联调用中的取消传播

Context.WithTimeout 是 Go 语言中控制并发操作生命周期的核心机制。在微服务或级联调用（A调用B，B调用C）中，当上游请求因超时被取消时，取消信号必须自动、迅速地传播到下游，以释放所有正在运行的 Goroutine 和数据库连接。

以下介绍如何在 Go 中实现完美的级联取消传播。

1. 理解 Context 的传播机制

Context 本质上是一棵树。当你创建一个派生 Context 时，它就成为了父 Context 的子节点。一旦父 Context 的超时时间到达，它会向所有的子 Context 发送取消信号。在级联调用中，这意味着最顶层的请求取消会瞬间触发底层所有函数的退出。

为了直观展示这一流程，请看以下执行路径与取消信号的传播关系：

2. 实现步骤与代码规范

步骤 1：创建带超时的上下文

在请求的入口点（通常是 HTTP Handler），创建一个带有超时的 Context。

输入以下代码，定义一个 2 秒超时的上下文：

package main

import (
    "context"
    "fmt"
    "time"
)

func Handler() {
    // 创建一个 2 秒后自动取消的 Context
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)

    // **调用** cancel 函数以确保资源最终被释放
    defer cancel()

    // 将 ctx 传递给下游
    CallServiceA(ctx)
}

步骤 2：在级联调用中透传 Context

确保 Context 作为函数的第一个参数进行传递。不要创建新的 context.Background()，否则会切断取消信号的传播链。

编写下游函数签名，始终将 ctx context.Context 放在首位：

func CallServiceA(ctx context.Context) {
    // 模拟一些预处理
    fmt.Println("Service A: 处理中...")

    // 继续将 ctx 传递给更下游
    CallServiceB(ctx)
}

func CallServiceB(ctx context.Context) {
    fmt.Println("Service B: 处理中...")

    // 传递给数据库或外部API调用
    QueryDatabase(ctx)
}

步骤 3：在阻塞操作中监听取消信号

这是最关键的一步。下游函数必须在执行耗时操作（如数据库查询、HTTP 请求）时，监听 <-ctx.Done() 通道。当该通道可读时，意味着上游已取消，当前函数应立即返回。

使用 select 语句来同时监听业务结果和取消信号：

func QueryDatabase(ctx context.Context) error {
    // 模拟一个耗时 5 秒的操作（超过了总超时时间 2 秒）
    resultChan := make(chan string)

    go func() {
        // 模拟数据库查询
        time.Sleep(5 * time.Second)
        resultChan <- "data"
    }()

    // **监听** Context 是否关闭
    select {
    case res := <-resultChan:
        fmt.Println("查询成功:", res)
        return nil
    case <-ctx.Done():
        // 当上游超时，这里会执行
        // ctx.Err() 通常是 context.DeadlineExceeded
        fmt.Println("查询被取消:", ctx.Err())
        return ctx.Err()
    }
}

步骤 4：处理标准库与第三方库

大多数 Go 标准库（如 net/http, database/sql）已经内置了 Context 支持。你只需要传递 Context 即可，它们会自动处理超时和取消。

配置 HTTP 请求，使其支持超时取消：

func CallExternalAPI(ctx context.Context) error {
    req, _ := http.NewRequestWithContext(ctx, "GET", "http://example.com", nil)

    client := &http.Client{}
    resp, err := client.Do(req)

    // 如果 ctx 超时，Do 方法会返回错误，且 resp 为 nil
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    return nil
}

3. 常见错误排查

在实现级联取消时，以下错误最容易导致资源泄露或逻辑失效。

4. 完整代码示例

将上述片段组合，运行以下代码以验证级联取消效果：

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 1. 创建超时上下文
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    fmt.Println("开始级联调用...")

    // 2. 启动调用链
    CallServiceA(ctx)

    // 等待观察输出
    time.Sleep(100 * time.Millisecond)
    fmt.Println("主函数结束")
}

func CallServiceA(ctx context.Context) {
    fmt.Println("进入 Service A")
    CallServiceB(ctx)
}

func CallServiceB(ctx context.Context) {
    fmt.Println("进入 Service B")

    // 模拟调用耗时操作
    err := HeavyTask(ctx)
    if err != nil {
        fmt.Println("Service B 捕获到错误:", err)
    }
}

func HeavyTask(ctx context.Context) error {
    // 模拟耗时 5 秒的工作（肯定超时）
    done := make(chan struct{})

    go func() {
        time.Sleep(5 * time.Second)
        close(done)
    }()

    select {
    case <-done:
        fmt.Println("任务完成")
        return nil
    case <-ctx.Done():
        // 这里会在 2 秒后被触发
        return ctx.Err()
    }
}