Go 里 goroutine 怎么用,新手入门教程

文章导读
在 Go 里启动一个并发任务只需要在函数调用前加 go 关键字,但真正需要判断的是后面三件事:这个任务能不能独立跑、结果要不要收回来、以及主函数退出时它是否还没跑完。新手最常见的问题不是不会写 go,而是写完发现程序提前结束、多个 goroutine 抢同一个变量,或者一口气起了太多 goroutine 把内存顶上去。可以先按“同步版能跑通,再加并发,再补等待和结果通道,最后加限流”的顺序处理。
📋 目录
  1. 一 先确认当前场景和目标
  2. 二 按这个顺序处理
  3. 三 改完后怎么验证
  4. 四 容易忽略的边界
A A

在 Go 里启动一个并发任务只需要在函数调用前加 go 关键字,但真正需要判断的是后面三件事:这个任务能不能独立跑、结果要不要收回来、以及主函数退出时它是否还没跑完。新手最常见的问题不是不会写 go,而是写完发现程序提前结束、多个 goroutine 抢同一个变量,或者一口气起了太多 goroutine 把内存顶上去。可以先按“同步版能跑通,再加并发,再补等待和结果通道,最后加限流”的顺序处理。

goroutine 适合用在一批彼此独立、耗时主要在等待(网络、磁盘、外部服务)的任务上。最小可用组合是 go 加 sync.WaitGroup 负责等全部结束;需要拿返回值时改用带缓冲 channel 收集;任务数量不可控时用固定 worker 数或信号量限制并发。验证方式是 go run -race / go test -race 不报数据竞争、输出条数与输入一致、程序能正常退出。如果任务之间强依赖、或本身是纯 CPU 计算且机器核数有限,并发通常不会带来好处,先保留串行版本。

先确认当前场景和目标

先别急着加 go,把下面几项确认清楚,后面写出来的代码才不容易返工:

  • 任务之间有没有依赖:B 必须等 A 的结果才能开始,就不该用 goroutine 硬拆;只有互不依赖、或者依赖关系能用 channel 明确表达时才适合并发。
  • 要不要拿回结果:只关心“都做完了”用 sync.WaitGroup;需要每个任务的返回值、错误,就要配 channel 或 errgroup 这类封装。
  • 有没有共享变量:多个 goroutine 同时写同一个 map、slice、计数器,是需要重点处理的地方,通常改成各写各的再汇总,或加 sync.Mutex。
  • 任务数量是否可控:从固定切片遍历,长度已知;从网络或文件读出来的任务条数未知,就必须考虑限流,否则可能瞬间起出大量 goroutine。
  • 主函数会不会提前返回:main 返回时整个进程结束,不会等待未完成的 goroutine,这一点和很多语言不同。

按这个顺序处理

第一步,先写一个能跑通的串行版本。用普通 for 循环把每个任务顺序执行完,确认逻辑和输出是对的。这一步是为了留一个对照基线,后面并发版出问题时可以切回来对比。

第二步,加 go 的同时补上等待。只加 go 不加等待,程序大概率还没执行完就退出了。用 WaitGroup 是最直接的写法:

var wg sync.WaitGroup
for _, id := range ids {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        handle(id)
    }(id)
}
wg.Wait()

注意把循环变量显式传进闭包。较老的 Go 版本里循环变量是复用的,直接引用可能让所有 goroutine 拿到同一个值;即使在新版本,显式传参也更不容易看错。可以结合自己用的 Go 版本确认语义,但显式传参这个写法各版本都安全。

第三步,要结果就用 channel 收集。已知任务数量时,用容量等于任务数的缓冲 channel,避免发送方被阻塞:

Go 里 goroutine 怎么用,新手入门教程
ch := make(chan int, len(ids))
var wg sync.WaitGroup
for _, id := range ids {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        ch <- square(id)
    }(id)
}
wg.Wait()
close(ch)
for v := range ch {
    fmt.Println(v)
}

这里 close 放在 wg.Wait() 之后,由发起方关闭,不要在每个 goroutine 里各自 close,重复关闭会 panic。

第四步,任务数量不确定时加限流。用带缓冲 channel 当信号量,是最简单、也最容易看懂的做法:

sem := make(chan struct{}, 8) // 同时最多 8 个
var wg sync.WaitGroup
for _, id := range ids {
    sem <- struct{}{}
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        defer func() { <-sem }()
        handle(id)
    }(id)
}
wg.Wait()

并发上限取多少要根据实际任务性质判断:偏 IO 等待的任务可以比 CPU 核数大一些,偏计算的任务取接近核数更合理。先给一个保守值跑一遍,观察耗时和内存再调整。

第五步,把错误也传回来。只传结果不传错误,出错时很难定位。可以在结果结构体里带上 err 字段,或者用 golang.org/x/sync/errgroup,任一任务返回错误时取消其余任务。

改完后怎么验证

验证不用复杂,关键是养成固定动作:

  1. 用 go run -race main.go 跑一遍,或者在测试里用 go test -race ./...。并发读写共享变量会在这里被报出来,没有报告是最基本的通过信号。
  2. 用小规模输入(比如几条、十几条)跑,核对输出条数、内容是否与串行版本一致。数量对不上,通常是 channel 容量不足导致漏收,或者 wg.Done() 漏写。
  3. 把输入放大到实际量级,观察进程能否正常结束而不是卡住。wg.Wait() 返回后仍挂起,往往是有 goroutine 在往一个没人读的 channel 发送。
  4. 如果程序会长期运行,可以接入 net/http/pprof,看 goroutine 数量在任务结束后是否回落到接近初始值;持续上涨说明有 goroutine 没有退出。

容易忽略的边界

  • goroutine 不是免费的:单个开销小,但任务量大时累积占用不可忽略。没有限流的写法在任务条数来自外部输入时风险更高。
  • 子 goroutine 里的 panic 会带崩整个进程,除非在内部用 recover 兜住。对不可信输入的处理函数,建议在 goroutine 入口加上 defer recover。
  • 不适用于强依赖链:任务必须严格按顺序执行、或后一步依赖前一步结果且无法拆解时,并发只会增加复杂度,直接串行。
  • 纯 CPU 计算且核数很少时,并发收益有限甚至因调度而更慢,这种场景先不要引入 goroutine。
  • 需要能被外部取消的长任务,要把 context 传进 goroutine 内部并在合适位置检查,否则调用方放弃后这些 goroutine 仍会继续跑。
  • 回退建议:一旦出现难以定位的卡死或数据竞争,先把并发改回串行版本确认业务逻辑无误,再逐个恢复 WaitGroup、channel、限流,每次只改一处,问题范围会小很多。