Goroutine同步是Go并发开发的基础课题,核心结论是:官方提供的sync包和channel机制足以覆盖绝大多数同步场景,而真正导致线上事故的往往是使用姿势而非工具本身。本文基于实际工程经验,梳理几种经过验证的Goroutine同步方案,并给出选型建议。
Goroutine之间不存在隐式的执行顺序,它们由Go运行时调度,无法预测谁先谁后。若多个Goroutine同时读写同一内存地址,会引发数据竞争(Data Race),轻则结果错误,重则程序崩溃。据Go官方文档《The Go Memory Model》明确规定:同一数据存在多个Goroutine并发访问时,至少一个访问是写操作,就必须通过同步机制来保证顺序。这正是Goroutine同步存在的根本原因。
一个常见错误是仅靠time.Sleep等待子Goroutine完成。Sleep无法保证调度完成,且在生产环境中会掩盖真正的同步问题。正确做法是使用语言提供的原生同步原语。
WaitGroup是等待一组Goroutine全部完成的最直接方案,它的核心方法只有三个:Add、Done、Wait。使用时必须保证Add在Wait之前调用,且Add的计数与Done的调用次数严格匹配,否则会造成死锁或提前退出。
package main
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go func(n int) {
defer wg.Done()
fmt.Println("worker", n)
}(i)
}
wg.Wait()
fmt.Println("all done")
}这段代码中,每个Goroutine执行完毕调用Done,主Goroutine在Wait处阻塞,直到计数器归零。WaitGroup适用于“只关心是否全部完成,不关心结果”的场景。对于需要收集返回值的情况,需要配合channel或共享内存加互斥锁。
当多个Goroutine要对共享变量做写操作时,必须使用互斥锁保证同一时刻只有一个Goroutine能修改数据。Mutex的锁定与解锁必须成对出现,推荐用defer来确保不会遗忘解锁,防止死锁。
package main
import (
"fmt"
"sync"
)
var counter int
var mu sync.Mutex
func increment() {
mu.Lock()
defer mu.Unlock()
counter++
}
func main() {
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
increment()
}()
}
wg.Wait()
fmt.Println(counter)
}去掉Mutex,counter的最终值大概率小于1000,这就是数据竞争的典型表现。Mutex粒度较粗时会影响并发性能,建议在临界区代码尽量短小,实在无法缩短时再考虑原子操作或分段锁。
Go谚语说“不要通过共享内存来通信,而应通过通信来共享内存”。Buffered Channel天然适合做任务队列,Unbuffered Channel则适合做同步信号。用channel收集多个Goroutine的结果时,需要先启动一个接收端循环,或者等待所有发送端关闭后再统一遍历。
package main
import (
"fmt"
"sync"
)
func worker(id int, ch chan<- int) {
ch <- id * 10
}
func main() {
const n = 5
ch := make(chan int, n)
var wg sync.WaitGroup
for i := 0; i < n; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
worker(id, ch)
}(i)
}
wg.Wait()
close(ch)
for v := range ch {
fmt.Println(v)
}
}这里的channel带缓冲,大小与Goroutine数量一致,所以不会出现发送阻塞。关闭channel必须等所有发送者结束后进行,否则向已关闭的channel发送会触发panic。使用channel时要注意阻塞风险,尤其是无缓冲channel,需要确保配对的接收方存在。
标准库sync包没有提供错误传播能力,官方扩展包golang.org/x/sync/errgroup提供了更高级的Goroutine同步模型。errgroup的Go方法启动子Goroutine,Wait方法会等待全部完成,并在任意一个任务返回非nil错误时取消整个组的执行。这个库在批处理、并行HTTP请求、多路IO读取等场景中非常实用。
package main
import (
"errors"
"fmt"
"golang.org/x/sync/errgroup"
)
func main() {
var g errgroup.Group
urls := []string{"https://a.com", "https://b.com", "https://c.com"}
for _, url := range urls {
u := url
g.Go(func() error {
if u == "https://b.com" {
return errors.New("mock failure")
}
fmt.Println("fetched", u)
return nil
})
}
if err := g.Wait(); err != nil {
fmt.Println("error:", err)
} else {
fmt.Println("all success")
}
}errgroup的取消机制基于context,它内部会在第一个错误发生后自动调用cancel,从而停止其他Goroutine的继续执行。但要注意:这不会强制终止已经运行的Goroutine,需要开发者在Goroutine内检查context是否已取消。
实际项目中经常混合使用多种同步方式,下表列出常见选型参考。
| 场景 | 推荐工具 | 优点 | 易错点 |
|---|---|---|---|
| 只等待完成 | sync.WaitGroup | 轻量、性能高 | 计数器不匹配会死锁 |
| 共享数据修改 | sync.Mutex / RWMutex | 控制临界区简单 | 锁粒度大影响并发 |
| 传递结果或任务 | channel | 天然支持流式处理 | 忘关闭或阻塞 |
| 并行任务需取消 | errgroup | 自动传播错误并取消 | 依赖context检查 |
以上几种方案并非互斥,反而经常组合使用。比如errgroup内部就用了WaitGroup加上context取消机制,channel也经常与WaitGroup搭配来实现安全的关闭。
第一个坑是WaitGroup的Add调用时机。Add必须在启动Goroutine之前执行,如果在Goroutine内部调用Add,可能发生Wait已经检查计数器为零的情况。正确做法是循环内先Add再go。
第二个坑是通道泄漏。发送端向无人接收的channel发送数据会永久阻塞,导致Goroutine无法退出。可设置超时或使用select加default分支,尽量使用带缓冲channel减少阻塞概率。
第三个坑是锁的拷贝。sync.Mutex和sync.WaitGroup都不允许复制,一旦复制会复制锁状态。使用结构体时避免值传递,统一用指针。go vet工具能检测出这类复制问题,建议在CI流程中加入vet检查。
第四个坑是Goroutine数量无上限。每一路任务都开一个Goroutine会导致调度开销增大,甚至内存耗尽。应使用worker pool模式限制并发数量,channel的缓冲区大小恰好可作为背压机制。
第五个坑是忽略context取消。即便用errgroup,如果任务内部不监听ctx.Done,取消机制无法真正中断受阻塞的系统调用。建议所有I/O函数都优先选择接受context参数的版本,比如http.NewRequestWithContext。
Go官方提供了-race编译选项,可以在运行时检测数据竞争。据Go官方《Race Detector》文档描述,它通过运行时记录所有内存访问并检测不同Goroutine的冲突,虽然增加数倍运行时间,但能捕获绝大多数隐性同步问题。在开发测试阶段建议始终开启-race运行测试,这是预防Goroutine同步bug最有效的手段之一。
工程上还应该遵循几条纪律:多个Goroutine写同一channel时,必须有且只有一个负责close;接收端使用for range循环时,发送端必须保证最终关闭channel;使用Mutex保护的对象尽量封装在独立结构体内部,避免外部直接访问。
Goroutine同步的四种主要工具——WaitGroup、Mutex、channel、errgroup——各有其不可替代的使用场景。选择原则不是追求高级,而是匹配需求:简单的等待用WaitGroup,保护数据用Mutex,传递数据用channel,同时需要错误传播和取消机制就用errgroup。任何同步方案都要配合-race检测和严格的代码审查,才能保证并发代码的长期稳定。
评论
加载中...