Go 里 context 被取消后,那些还在跑的 goroutine 怎么办

Go并发context

先说结论,因为这句话我花了很久才真正理解:

context.WithCancel 的 cancel 只做一件事——把 channel 关掉。它不等待任何 goroutine 退出。

这不是 bug,是设计。但如果不理解,就会写出「以为任务已经收尾了,其实还在跑」的代码。

出问题的代码

一个批处理服务,收到任务后开 goroutine 干活,主流程收到退出信号就 cancel:

func (s *Service) Run(ctx context.Context) error {
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()

    for task := range s.taskCh {
        go func(t Task) {
            s.process(ctx, t)
        }(task)
    }
    return nil
}

func (s *Service) process(ctx context.Context, t Task) {
    // 中间有几个耗时的外部调用
    s.upload(ctx, t.Data)
    s.markDone(ctx, t.ID)
}

看起来没问题:ctx cancel 之后 upload 和 markDone 里的 http 请求会因为 ctx 被取消而失败返回。

问题出在两点:

  1. upload 里用的是 http.NewRequestWithContext,取消后请求确实会中断——但服务端可能已经收到并开始处理了,而 markDone 永远不会执行。任务状态卡在「处理中」。
  2. Run 返回时,那些 goroutine 还在跑。主进程 os.Exit 之后它们被硬杀,日志里什么都没留下。

正确的做法:分开「通知」和「等待」

把 cancel 和 WaitGroup 一起用。cancel 负责通知,WaitGroup 负责说「我等到你了」。

func (s *Service) Run(ctx context.Context) error {
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()

    var wg sync.WaitGroup
    defer wg.Wait()   // 关键:返回前等所有任务收尾

    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case task, ok := <-s.taskCh:
            if !ok {
                return nil
            }
            wg.Add(1)
            go func(t Task) {
                defer wg.Done()
                s.process(ctx, t)
            }(task)
        }
    }
}

注意 defer 的顺序:wg.Wait() 声明在 cancel() 之后,所以它先执行——先等 goroutine 结束,再取消 context。如果顺序反了,goroutine 会在收到取消信号后立刻退出,等于是白等。

这里有个容易绕晕的点:defer 是后进先出,所以写在前面的 defer cancel() 最后执行。想清楚这个顺序,代码就不会错。

给任务留一个「优雅收尾」的窗口

上面那样还不够。如果 process 内部用同一个 ctx,取消时它依然会在中途失败。常见做法是给收尾阶段一个独立的、带超时的 context:

func (s *Service) process(ctx context.Context, t Task) {
    // 业务逻辑跟随主 ctx,随时可中断
    if err := s.transform(ctx, t); err != nil {
        return
    }

    // 收尾阶段:脱离主 ctx,但有硬超时,避免真的卡死
    doneCtx, doneCancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Second)
    defer doneCancel()

    if err := s.markDone(doneCtx, t.ID); err != nil {
        s.log.Errorf("task %s 状态回写失败: %v", t.ID, err)
    }
}

context.WithoutCancel 是 Go 1.21 加的。在没有它之前,大家一般是 context.Background() 加超时,效果差不多,但会丢掉 ctx 上的 value(比如 trace id),排查问题时挺麻烦。

几个常踩的坑

坑一:time.After 在循环里

for {
    select {
    case <-ctx.Done():
        return
    case <-time.After(time.Second):   // 每次循环都新建一个 Timer
    }
}

在 1.23 之前,time.After 的 Timer 在触发前不会被 GC 回收,高频循环会堆一堆 Timer。用 time.NewTicker 加 defer ticker.Stop()。

坑二:把 ctx 存进 struct

type Handler struct {
    ctx context.Context   // 不要这样
}

ctx 应该是第一个参数,随调用链传递。存进 struct 之后生命周期就说不清楚了,谁 cancel 的、什么时候 cancel 的会变得很难查。

坑三:nil ctx

context.TODO() 和 nil 不是一回事。传 nil 给需要 ctx 的函数,如果对方调了 ctx.Done() 会直接 panic。不确定就用 context.TODO(),至少它能跑。

一句话总结

cancel 是广播,WaitGroup 是收拢。 想让服务优雅退出,两个都得有;只 cancel 不等待,等于把清理逻辑交给了 os.Exit。