Go语言context超时控制与取消传播实战：避免goroutine泄露

context超时控制的核心机制

Go的context包为goroutine提供了超时、取消和值传播的标准机制。生产环境最常见的错误是：goroutine启动后无法被取消，导致资源泄露。context.WithTimeout和context.WithCancel是解决这个问题的核心工具。

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

result, err := doWork(ctx)
if err != nil {
    if ctx.Err() == context.DeadlineExceeded {
        log.Printf('operation timed out')
    }
    return err
}

cancel()必须被调用，否则context的内部计时器和相关资源不会被释放。使用defer cancel()是最安全的做法。

取消信号的传播链

context的设计遵循父子传播规则：父context取消时，所有由它派生的子context自动取消。这个特性使得一个顶层的取消操作可以同时终止整条调用链上的所有goroutine。

func handleRequest(ctx context.Context) error {
    ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
    defer cancel()

    g, gCtx := errgroup.WithContext(ctx)

    g.Go(func() error {
        return callServiceA(gCtx)
    })
    g.Go(func() error {
        return callServiceB(gCtx)
    })

    if err := g.Wait(); err != nil {
        cancel()
        return err
    }
    return nil
}

errgroup.WithContext创建的共享context在任一goroutine返回error时自动取消，其余goroutine的context.Done()通道收到信号。

goroutine泄露的典型场景与修复

场景一：HTTP请求未检查context

// 错误写法：请求可能永远阻塞
func fetch(ctx context.Context, url string) ([]byte, error) {
    resp, err := http.Get(url)
    // ...
}

// 正确写法：使用带context的请求
func fetch(ctx context.Context, url string) ([]byte, error) {
    req, err := http.NewRequestWithContext(ctx, 'GET', url, nil)
    if err != nil {
        return nil, err
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}

场景二：channel阻塞导致goroutine无法退出

// 错误写法：channel写入阻塞，goroutine泄露
func process(ctx context.Context, ch <-chan int) {
    for val := range ch {
        result := expensiveCompute(val)
        fmt.Println(result)
    }
}

// 正确写法：用select检查context
func process(ctx context.Context, ch <-chan int) {
    for {
        select {
        case <-ctx.Done():
            log.Println('process cancelled:', ctx.Err())
            return
        case val, ok := <-ch:
            if !ok {
                return
            }
            result := expensiveCompute(val)
            fmt.Println(result)
        }
    }
}

context值传递的正确用法

context.WithValue用于请求级别的元数据传递（trace ID、auth token），不适合做依赖注入容器。类型安全的做法是定义自定义类型键：

type ctxKey string

const traceIDKey ctxKey = 'trace-id'

func withTraceID(ctx context.Context, id string) context.Context {
    return context.WithValue(ctx, traceIDKey, id)
}

func getTraceID(ctx context.Context) string {
    v, _ := ctx.Value(traceIDKey).(string)
    return v
}

取值时用类型断言，避免panic。WithValue不影响context的取消和超时行为——它只在值空间添加一条记录。

超时时间的层级设计

调用链上的超时时间应该逐层递减，确保上游超时先于下游触发。例如：API层10秒到服务层8秒到数据库层5秒。

func apiHandler(ctx context.Context) {
    ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
    defer cancel()

    svcCtx, svcCancel := context.WithTimeout(ctx, 8*time.Second)
    defer svcCancel()

    result := callService(svcCtx)
}

func callService(ctx context.Context) {
    dbCtx, dbCancel := context.WithTimeout(ctx, 5*time.Second)
    defer dbCancel()

    row := db.QueryRowContext(dbCtx, 'SELECT ...')
}

如果服务层超时设为15秒（超过API层10秒），API层超时后服务层的goroutine还在继续执行——这就是泄露。每个层级的超时必须小于其父context的超时。

监控与调试

在中间件层注入context超时监控：

func timeoutMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
        defer cancel()

        r = r.WithContext(ctx)
        next.ServeHTTP(w, r)

        elapsed := time.Since(start)
        if ctx.Err() == context.DeadlineExceeded {
            metrics.TimeoutCounter.Inc()
            log.Printf('request timeout: path=%s elapsed=%s', r.URL.Path, elapsed)
        }
    })
}

配合pprof的goroutine分析，定期检查泄露的goroutine数量，关注长时间运行的goroutine是否正确处理了context取消信号。