Golang并发任务优雅停止方法示例

使用context实现优雅停止，通过cancel信号通知协程退出并执行清理。示例展示worker监听ctx.Done()中断信号，结合channel确认任务完成，确保主程序在所有清理结束后再退出，适用于阻塞操作的可中断处理。

在Go语言中，处理并发任务时如何优雅地停止是一个常见且重要的问题。所谓“优雅停止”，是指在程序退出或任务被取消时，正在运行的协程能够及时收到信号、完成清理工作（如关闭资源、保存状态），而不是被 abrupt 终止。

使用 context 控制协程生命周期

Go 的 context 包是管理协程生命周期的标准方式。通过 context.WithCancel 可以创建一个可取消的上下文，当调用 cancel 函数时，所有监听该 context 的 goroutine 都能收到中断信号。

示例代码：

下面是一个启动多个后台任务，并通过 context 实现统一关闭的例子：

package main

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

func worker(ctx context.Context, id int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d 退出：收到停止信号\n", id)
            return
        default:
            fmt.Printf("Worker %d 正在工作...\n", id)
            time.Sleep(1 * time.Second)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    // 启动3个worker
    for i := 1; i <= 3; i++ {
        go worker(ctx, i)
    }

    // 模拟运行5秒后停止
    time.Sleep(5 * time.Second)
    fmt.Println("准备关闭所有任务...")
    cancel() // 触发所有协程退出

    // 留出时间让worker完成退出
    time.Sleep(1 * time.Second)
    fmt.Println("主程序退出")
}

在这个例子中，每个 worker 不断检查 ctx 是否已 Done。一旦调用 cancel()，ctx.Done() 通道会关闭，select 能立即感知并退出循环。

结合 channel 实现更精细控制

除了 context，有时需要配合 channel 来通知外部任务已完全停止。比如监控所有 worker 是否真正退出。

改进版示例：

func workerWithSignal(ctx context.Context, id int, done chan<- bool) {
    defer func() {
        done <- true // 通知已完成清理
    }()

    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d 收到退出指令，开始清理...\n", id)
            // 模拟清理操作
            time.Sleep(500 * time.Millisecond)
            fmt.Printf("Worker %d 清理完成\n", id)
            return
        default:
            fmt.Printf("Worker %d 运行中\n", id)
            time.Sleep(1 * time.Second)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    done := make(chan bool, 3) // 缓冲channel避免阻塞

    for i := 1; i <= 3; i++ {
        go workerWithSignal(ctx, i, done)
    }

    time.Sleep(4 * time.Second)
    fmt.Println("发送停止信号...")
    cancel()

    // 等待所有worker完成退出
    for i := 0; i < 3; i++ {
        <-done
    }
    fmt.Println("所有任务已安全退出，程序结束")
}

这里使用带缓冲的 done channel 收集每个 worker 的退出确认，确保主程序不会在清理完成前终止。

处理长时间阻塞操作的中断

如果 worker 中有阻塞调用（如网络请求、文件读写），需确保这些操作也能响应 context。建议使用支持 context 的函数，例如 http.Get 替换为 client.Do(req.WithContext(ctx))。

模拟可中断的阻塞任务：

func blockingWorker(ctx context.Context, id int) {
    ticker := time.NewTicker(500 * time.Millisecond)
    defer ticker.Stop()

    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d 被中断，退出阻塞任务\n", id)
            return
        case <-ticker.C:
            fmt.Printf("Worker %d 处理中...\n", id)
        }
    }
}

通过将阻塞循环改为 select + ticker，可以周期性检查 ctx 状态，实现快速响应中断。

基本上就这些。核心思路是：用 context 作为统一的停止信号源，在每个协程中监听它，并在收到信号后执行必要的清理逻辑。配合 channel 可实现更可靠的同步等待。这样既能保证程序健壮性，也符合 Go 的并发哲学。