一篇文章讲清 Go 并发:goroutine、channel、select 与取消

写 Go 并发代码时,最容易误解的不是 go 关键字,而是"这个 goroutine 什么时候结束、谁负责关闭 channel、调用方提前离开后谁来通知剩余任务"。本文沿着一条任务处理链,解释 goroutine、channel、select 和 context 如何协作,再用一份 worker pool 示例把退出路径串起来。适合已经会写基础 Go 函数和循环、准备做并发任务的开发者。

下面的代码基于 Go 标准库 API 编写,未在当前环境执行 。读者可以保存为 main.go 后按文末步骤验证;并发输出顺序没有固定保证,不应把某次输出顺序当成语言规范。

并发和并行,先分清讨论对象

并发是把任务组织成能够交错推进的独立执行单元;并行是多个任务在同一时间实际运行。Go 的 go f() 会让函数调用在一个新的 goroutine 中执行,但这不等于每个 goroutine 独占一个操作系统线程,也不保证启动顺序就是完成顺序。程序是否利用多个核、能否缩短耗时,还取决于调度、工作负载和资源约束。Effective Go也明确区分了并发结构与并行执行。

以批量计算商品价格为例,可以让多个 worker 同时处理任务。此时至少需要三种关系:谁生产待处理任务、谁执行、谁收集结果。Go 常用 channel 在这些角色之间传值,用 sync.WaitGroup 等机制等待完成,用 context 传递取消信号。

图 1:以批量计算订单价格为业务示意,展示任务数据流和取消、等待、关闭的控制链。后文代码用整数平方代替实际价格计算。

图中的任务生产者把订单编号送入 jobs,固定数量的 worker 从中取任务,计算后写入 results。调用方从 results 接收结果;只有在所有 worker 都结束后,协调者才关闭 results,这样接收方的 range 才能可靠结束。如果调用方决定提前停止,取消信号需要同时让生产者和可能阻塞在发送结果的 worker 有退出路径。

goroutine 是执行单元,不是"扔出去就不管"

go f() 会启动一个新的 goroutine 执行 f。调用方不会等待它自动完成;如果 main 先返回,程序就会结束,后台任务未必有机会走完。反过来,如果 goroutine 一直等着无人接收的 channel、永不结束的网络操作或没有触发的退出信号,它可能长期占用内存和关联资源。这类问题常被称为 goroutine 泄漏。

因此,设计一个 goroutine 时要同时写下三个答案:它等待什么、谁能解除等待、退出后谁负责回收或通知。WaitGroup 适合等待一组任务完成;channel 适合传值或信号;context 适合从调用链上游传播取消。三者职责不同,不能只加一个 WaitGroup 就认为所有阻塞都会自行解除。

channel 的关键是阻塞与所有权

make(chan T) 创建无缓冲 channel。发送需要有接收方配对,接收也需要有发送方配对,双方才可以继续。make(chan T, n) 创建容量为 n 的缓冲 channel:未满时发送可以先放入缓冲区,未空时接收可以先取出元素;缓冲满时发送会等待,缓冲空时接收会等待。缓冲只能吸收有限的速率差,并不保证 goroutine 永远不会卡住。Go 语言规范的 Channel types描述了这些语义。

图 2:同样是发送与接收,缓冲容量和关闭状态决定了操作能否继续。关闭后,缓冲里的旧值仍可被接收。

这张图重点不是"有缓冲就更快",而是发送与接收各自什么时候需要等待。假如 producer 每秒产出超过 worker 能处理的量,容量为 10 的缓冲区也会填满;它只改变短时间内谁先阻塞,不改变系统的长期吞吐上限。容量应由峰值、内存占用和背压需求决定,而不是随意设成很大。

关闭 channel 表示"以后不会再发送值",并不是销毁 channel,也不是清空其中已有数据。接收方会先读完缓冲中的值;之后接收才得到元素类型的零值与 ok == false。for v := range ch 会在 channel 关闭并取完剩余值后结束。向已经关闭的 channel 发送或再次关闭它会 panic。Go 语言规范的 Close给出了精确定义。

实践中通常让拥有发送权、且确定所有发送者都已经结束的一方 关闭 channel。一个 producer 独占 jobs 的发送,结束时关闭 jobs 很自然;多个 worker 共同写 results,任何单个 worker 都不能在自己结束时关闭它,否则其他 worker 可能继续发送并触发 panic。应由等待全部 worker 完成的协调者统一关闭。

select 是在多个通信条件中选择就绪分支

select 的每个 case 是一次 channel 发送或接收。当多个分支都可执行时,会从可执行分支中选择一个;不应依赖它固定先处理哪一个。没有可执行分支且没有 default 时会阻塞;加入 default 后则可立即走默认分支,但在循环中盲目使用 default 可能形成空转,耗费 CPU。具体规则见 Go 语言规范的 Select statements。

常见用法是让一次发送既能等待消费者,也能响应取消:

go 复制代码
select {
case results <- value:
    // 结果被接收,或进入缓冲区。
case <-ctx.Done():
    return // 调用方已不需要结果,退出当前 goroutine。
}

这里有一个容易忽略的边界:取消发生时,发送分支也可能恰好就绪。select 不承诺取消分支一定优先,所以取消不等于"从这一刻起绝不再有结果"。如果业务必须严格禁止取消后写入结果,需要在更高层设计状态机或同步协议;仅靠这个 select 不能提供那种强保证。

用一个 worker pool 把生命周期写完整

下面的示例把整数当成待处理任务,让三个 worker 计算平方,调用方在看到结果 9 时请求取消。它演示的是通道所有权与退出路径,计算本身只是占位任务。保存为 main.go;只使用标准库。由于没有在当前环境运行,请在目标 Go 环境中执行并检查输出。

go 复制代码
package main

import (
    "context"
    "fmt"
    "sync"
)

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

    jobs := make(chan int)
    results := make(chan int)

    var workers sync.WaitGroup
    for i := 0; i < 3; i++ {
        workers.Add(1)
        go func() {
            defer workers.Done()
            for {
                select {
                case <-ctx.Done():
                    return
                case n, ok := <-jobs:
                    if !ok {
                        return
                    }
                    value := n * n
                    select {
                    case results <- value:
                    case <-ctx.Done():
                        return
                    }
                }
            }
        }()
    }

    producerDone := make(chan struct{})
    go func() {
        defer close(producerDone)
        defer close(jobs) // 唯一的 jobs 发送者负责关闭它。
        for n := 1; n <= 6; n++ {
            select {
            case jobs <- n:
            case <-ctx.Done():
                return
            }
        }
    }()

    go func() {
        workers.Wait()
        close(results) // 所有 worker 退出后才关闭结果通道。
    }()

    for value := range results {
        fmt.Println(value)
        if value == 9 {
            cancel()
        }
    }
    <-producerDone
}

这个例子的顺序值得逐行看:先启动 worker,再启动 producer;producer 是 jobs 唯一发送者,结束时关闭 jobs;worker 在接收任务和发送结果时都监听 ctx.Done();协调 goroutine 等所有 worker 返回后才关闭 results;主 goroutine 一直读取到结果通道关闭,再等 producer 退出。这样既能正常处理完全部任务,也能在提前取消时释放可能卡在发送上的 goroutine。

输出的数字集合与顺序取决于调度:多个 worker 并发计算,9 可能并不是第三个打印的数字;cancel() 发出后也可能再读到已经就绪的结果。示例不要求输出固定为 1、4、9,它要验证的是程序最终退出、没有因为发送或接收永远等待。

context 的取消信号究竟做了什么

context.WithCancel(parent) 返回子 context 和 cancel 函数。调用 cancel() 会关闭子 context 的 Done() 通道,并向从它派生的 context 传播取消;它不会 强制杀掉 goroutine。代码必须主动从 ctx.Done() 接收,并在合适位置返回。官方 context 包文档还要求使用完派生 context 后调用取消函数,以释放相关资源。

这意味着一个只做 time.Sleep、不检查 context 的 worker,收到取消后并不会立刻停;一个已经进入不可取消的外部调用的 worker,也只能等调用返回或底层 API 自身支持取消。生产系统要把 context 继续传给 HTTP 请求、数据库查询等支持它的 API,而不是只在最外层创建一个 context。

取消和关闭也不是一回事:取消是"这项工作不再需要继续"的控制信号;关闭 jobs 是"没有更多任务会发送"的数据流终止信号;关闭 results 是"不会再有结果"的完成信号。在正常完成路径和提前退出路径中,这三种事件的发生时机可能不同。

channel 已经传值,为什么还可能有数据竞争

channel 的一次发送与对应接收之间建立同步关系,这是 Go 内存模型的明确规定。但"程序里用了 channel"不等于共享变量自动安全。例如,两个 worker 同时修改同一个普通 map,如果没有 mutex、单一所有者或其他正确同步,仍可能发生数据竞争。channel 只为实际参与通信的操作提供相应的顺序保证。

如果多个 goroutine 需要更新同一份状态,先问能否让一个 goroutine 独占状态、其余通过 channel 提交操作;如果共享内存更直接,使用 sync.Mutex 等同步原语。不要为了遵守口号把所有读写都强行包装成 channel。Go 官方的 Data Race Detector 文档给出了 go test -race 与 go run -race 的用法;它能发现运行路径中实际触发的数据竞争,不能替代完整的并发设计审查。

如何验证和排查卡住的问题

安装 Go 后,把示例保存为 main.go,执行 go run main.go。重点观察程序是否结束,而不是数字顺序。接着可运行 go run -race main.go,或在真实项目里执行 go test -race ./...。若后续修改让程序卡住,先检查:是否有无人接收的发送、无人关闭的 range、多个发送者争相关闭同一 channel、提前退出后未通知上游、或 context 没有传到真正阻塞的操作。

调试时可以在生产者、每个 worker 与结果协调者的退出点加日志,记录"谁关闭了哪个 channel"。如果仍不好定位,再结合 goroutine 堆栈观察阻塞位置。给 channel 增大缓冲区可能掩盖短时卡顿,却不会修复没有退出路径的 goroutine。

结语

Go 并发代码能否长期稳定,关键不在启动了多少 goroutine,而在任务与信号的所有权是否清楚。go 负责开启独立执行;channel 负责传值和同步;select 在数据流与取消之间选择;context 传递停止请求;等待机制负责知道所有发送者何时结束。按"谁发送、谁接收、谁关闭、谁取消、谁等待"检查每条路径,比记住几个语法示例更可靠。

参考资料

相关推荐
afumu14 小时前
Go 写一个只监听 127.0.0.1 的控制服务:鉴权、白名单、危险命令拦截
后端·安全·go
我不会起名字32220 小时前
未接入最终读上限的参数:`websocketMaxMsgLen` 与 12.5 倍差距
后端·websocket·go·即时通讯·im·故障排查
王中阳Go1 天前
100 件货卖出 116 件,库存停在 -16
后端·mysql·go
我不会起名字3222 天前
req.Seqs[len-1]:空切片防御缺口与 RPC 二次校验
后端·mongodb·go·即时通讯·im·故障排查
我不会起名字3223 天前
会话缓存失效排查:区分 Redis 失效与节点广播
redis·后端·go·即时通讯·im·故障排查
大然Ryan4 天前
我用 Go 和 AI 做了一个 macOS 磁盘清理工具:Vole(开源)
go
我不会起名字3224 天前
seq 空洞排查:Mongo 的 51 只是预留上界,Redis CURR 才是已消耗边界
redis·后端·mongodb·go·即时通讯·im·故障排查
喵个咪5 天前
GoWind 拆解:全链 ID 类型体系——int64 定版与前端字符串化契约
前端·后端·go
喵个咪5 天前
GoWind CMS 拆解:发布审批——多级推进、逐级角色与全程留痕
前端·后端·go