Go语言中context.WithTimeout超时不生效，求非手动检查的解决方案

首先明确：context.WithTimeout 是协作式的，它不会主动终止代码执行——只有当代码主动监听并响应 ctx.Done() 信号时，超时逻辑才会生效。你遇到sleep后仍返回200的问题，本质是sleep操作完全不感知context状态，不会因ctx超时而中断。

除了手动检查ctx，以下是几种可行的解决方案：

1. 让阻塞操作响应context信号 #

把不感知context的阻塞操作（比如time.Sleep）替换为监听ctx.Done()的select逻辑，确保超时触发时能立即终止执行：

func handler(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
    defer cancel()

    select {
    case <-ctx.Done():
        // 超时触发，返回错误
        http.Error(w, ctx.Err().Error(), http.StatusRequestTimeout)
        return
    case <-time.After(15 * time.Second):
        // 模拟耗时操作完成
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("success"))
    }
}

2. 使用支持context的标准库/第三方库函数 #

大部分Go标准库的耗时操作都提供了带context的版本，这些函数内部会自动监听ctx.Done()，超时后自动终止：

• HTTP请求：用http.NewRequestWithContext替代http.NewRequest
• 数据库操作：比如database/sql的QueryContext、ExecContext

示例（HTTP请求超时控制）：

func handler(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, "GET", "https://example.com/slow-api", nil)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        // 超时或其他错误会在这里返回
        http.Error(w, err.Error(), http.StatusRequestTimeout)
        return
    }
    defer resp.Body.Close()

    w.WriteHeader(http.StatusOK)
    io.Copy(w, resp.Body)
}

3. 用context管理goroutine生命周期 #

如果API逻辑启动了子goroutine，必须通过ctx.Done()信号控制子goroutine的退出，避免资源泄漏和无效执行：

func handler(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
    defer cancel()

    resultChan := make(chan string)
    go func() {
        // 模拟耗时操作
        time.Sleep(15 * time.Second)
        select {
        case resultChan <- "success":
        case <-ctx.Done():
            // 超时后直接退出，不再发送结果
            return
        }
    }()

    select {
    case <-ctx.Done():
        http.Error(w, "request timed out", http.StatusRequestTimeout)
        return
    case res := <-resultChan:
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(res))
    }
}

4. 封装通用超时控制函数 #

把需要超时控制的逻辑封装成通用函数，统一处理context监听，减少重复代码：

func runWithTimeout(ctx context.Context, timeout time.Duration, fn func() (string, error)) (string, error) {
    ctx, cancel := context.WithTimeout(ctx, timeout)
    defer cancel()

    resultChan := make(chan string)
    errChan := make(chan error)

    go func() {
        res, err := fn()
        if err != nil {
            errChan <- err
            return
        }
        resultChan <- res
    }()

    select {
    case <-ctx.Done():
        return "", ctx.Err()
    case err := <-errChan:
        return "", err
    case res := <-resultChan:
        return res, nil
    }
}

// 使用示例
func handler(w http.ResponseWriter, r *http.Request) {
    res, err := runWithTimeout(r.Context(), 10*time.Second, func() (string, error) {
        time.Sleep(15 * time.Second)
        return "success", nil
    })

    if err != nil {
        http.Error(w, err.Error(), http.StatusRequestTimeout)
        return
    }

    w.WriteHeader(http.StatusOK)
    w.Write([]byte(res))
}

总结：context超时生效的关键是所有耗时逻辑都必须主动响应ctx.Done()信号，要么自己写select监听，要么用支持context的库函数，这是Go context协作式取消的核心原则。

内容的提问来源于stack exchange，提问作者Rakshit P R Vashishta