一个统计接口每天凌晨汇总前一天的数据,逻辑很简单:起一批 goroutine 处理分片,每个处理完给全局计数加一,最后打印总数。大部分时候数字正确,偶尔少几个,重跑一次又对了。没有报错,没有崩溃,日志里什么都看不出来。
这类问题的根源是数据竞争:多个 goroutine 在没有同步的情况下读写同一块内存,结果取决于执行顺序。Go 的 n++ 看起来是一条语句,实际上分成读、加、写三步,两个 goroutine 交错执行时,一次加一会被另一次覆盖。更麻烦的是,它可能几万次才出现一次,测试环境永远复现不了。
这篇讲并发编程里最核心的几件事:竞态是怎么产生的、怎么用 -race 抓到它、互斥锁到底保护什么、channel 的阻塞和关闭规则、以及 worker 池的正确写法。目标不是把所有并发原语列一遍,而是让你在看到「偶尔少一次」「偶尔卡住」「偶尔 panic」时,知道往哪个方向查。
n++ 不是一步操作
先看一个最小复现。一百个 goroutine 各自对同一个变量加一,等全部结束后打印:
var n int
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
wg.Add(1)
go func() {
defer wg.Done()
n++
}()
}
wg.Wait()
fmt.Println("n =", n)
本机用 go run -race main.go 运行,输出里首先出现的是竞态报告:
WARNING: DATA RACE
Read at 0x00c00000c128 by goroutine 10:
main.main.func1()
.../a7-race/main.go:15
Previous write at 0x00c00000c128 by goroutine 8:
main.main.func1()
.../a7-race/main.go:15
最后打印 n = 100,看起来是对的,但报告里写着 Found 2 data race(s),进程以退出码 66 结束。这说明「结果正确」不代表「没有竞态」:这一百次恰好没有丢掉更新,换一台机器、换一个调度顺序,就可能变成 97、98。并发 bug 的可怕之处就在这里,它不是每次都错,而是错的时候你很难归因。
n++ 的底层是「读取当前值、加一、写回」。两个 goroutine 同时读到 5,各自算出 6,再写回 6,两次加一只生效了一次。这不是编译器优化的问题,任何语言里非原子的读改写都有这个风险。
有人会问:最后调用了 wg.Wait(),不是已经等所有 goroutine 结束了吗?Wait 保证的是「它们都做完了」,不是「它们做的时候互不干扰」。它建立的是「主 goroutine 能看到全部结果」的先后关系,管不了 goroutine 之间的并发写入。这两件事经常被混为一谈,也是加锁位置写错的常见原因。
竞态检测器:怎么读那段报告
go test -race 或 go run -race 会给程序加上检测代码,记录每次内存访问和同步事件。发现两个 goroutine 访问同一地址、其中至少一个是写、且中间没有建立 happens-before 关系时,就打印 WARNING: DATA RACE。
报告的结构是固定的:先给出当前访问的位置(Read 或 Write),再给出「上一次」访问的位置,最后是创建这两个 goroutine 的调用栈。读报告时,先看两组栈是不是指向同一个变量,再看它们之间有没有锁、channel、atomic 之类的同步。报告里的地址每次运行都不同,行号才是关键。
几个使用要点:第一,检测器只能发现「实际执行到的」竞态,没走到的分支不会报,所以测试要覆盖并发路径。第二,开启后程序会变慢、内存占用变高,适合测试环境,不适合长期在生产跑。第三,它报告的是数据竞争,不是逻辑竞争:两个 goroutine 都加锁了,但加锁顺序不同导致死锁,它不会报。
CI 里应该固定跑一遍带 -race 的单测。很多团队只在本地偶尔跑,结果竞态代码合进了主干,等到线上才暴露。代价是测试时间变长,但比事后排查便宜得多。
检测器可以通过环境变量调整,比如 GORACE="halt_on_error=1" 让它在第一次发现竞态时就退出,适合在流水线里快速失败。不要在生产环境长期开启,它的内存开销可能是正常运行的几倍,而且只有在触发路径上才有意义。
锁保护的是数据,不是代码
修上面的计数器,最直接的办法是加互斥锁。关键在于锁必须保护「同一份数据」,而不是「看起来相似的代码」。
type Counter struct {
mu sync.Mutex
n int
}
func (c *Counter) Inc() {
c.mu.Lock()
defer c.mu.Unlock()
c.n++
}
用指针接收者,起一千个 goroutine,本机输出 计数: 1000,稳定正确。把接收者改成值类型 func (c Counter) Inc(),每个 goroutine 调用时都会复制一份 Counter,锁和计数器都各自独立,加锁完全失去意义。本机实测输出是 计数: 0,因为每次自增改的都是副本,原对象从未被更新。
这种写法 go vet 能查出来。本机实际输出:
main.go:13:9: Inc passes lock by value: command-line-arguments.Counter contains sync.Mutex
只要结构体里含 sync.Mutex、sync.RWMutex、sync.Once 这类不可复制类型,就应该用指针接收者,也不要按值传参、不要放进值类型的 map 里。复制锁不会报错,只会让同步悄悄失效。
锁的范围也要注意。只在「读」或只在「写」的一侧加锁,等于没加;在锁内做网络请求、读文件、写日志,会把临界区拉得很长,其他 goroutine 全在排队。正确的粒度是「只包住共享数据的访问」,把耗时操作移到锁外。需要同时锁多个对象时,所有代码按同一顺序加锁,否则两个 goroutine 各持一把、互相等待,就是死锁。
死锁的经典形状是:goroutine A 持有锁 1、申请锁 2,goroutine B 持有锁 2、申请锁 1。两边都不释放,程序就卡在那里,CPU 为 0,日志不再前进。它和 channel 死锁的表现很像,但栈里看到的是 sync.Mutex.Lock 而不是 chan send。避免办法不是「小心一点」,而是给所有锁定义全局顺序,任何代码都按这个顺序获取。
channel:阻塞、关闭和所有权
channel 是 goroutine 之间传值和同步的工具,但它有几条容易忽略的规则。
无缓冲 channel 的发送会一直阻塞,直到有人接收。如果主 goroutine 自己发送、又没人接收,程序会直接报死锁。本机实际输出:
准备发送
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
.../a7-deadlock/main.go:8
exit status 2
这条 fatal error 的意思是「所有 goroutine 都睡着了,没有任何一个能推进」。运行时会做死锁检测,把所有 goroutine 的栈打出来。看到 [chan send],就去找配对的接收方;看到 [chan receive],就去找发送方或关闭方。大多数死锁不是语法错误,而是「某一方提前退出了」。
关闭 channel 有两条硬规则:只能由发送方关闭,且只能关一次。重复关闭会 panic。本机实测:
第一次关闭成功
panic: close of closed channel
...
exit status 2
向已关闭的 channel 发送也会 panic,错误是 send on closed channel。从已关闭的 channel 接收则是安全的:会立刻返回零值和 false,循环 range 会自动结束。所以关闭是一种「广播结束」的机制,适合「生产者在某个时刻不再生产」的场景。
所有权要明确:谁创建 channel,谁负责关闭;如果有多个生产者,就要用 sync.WaitGroup 等所有生产者结束后再关,或者由一个协调者关闭。多个 goroutine 都以为自己该关,就会重复关闭;没人关,接收方就永远等下去。
select 可以同时等多个 channel。带 default 分支时,没有任何 case 就绪会立刻走 default,适合做「非阻塞尝试」;不带 default 就会一直等,直到某个 case 就绪。等的时候如果所有 channel 都是 nil,同样会永久阻塞,这一点和第 1 篇的 nil channel 呼应。
带缓冲的 channel 在容量未满时发送不会阻塞,接收在缓冲区为空时才阻塞。缓冲能削峰,但也会掩盖「消费端太慢」的问题:生产者一直写得很顺,内存里堆着几千条没处理的消息,直到缓冲区满才突然阻塞。观察 len(ch) 和 cap(ch) 的差距,比只看「有没有卡住」更早发现问题。
worker 池:关闭 jobs,收集 results
把任务分给固定数量的 goroutine,是最常见的并发模式。核心是两条 channel:一条发任务,一条收结果;任务发完后关闭 jobs,worker 的 range 循环自然结束。
jobs := make(chan int)
results := make(chan int)
for w := 0; w < 3; w++ {
go func() {
for n := range jobs {
results <- n * n
}
}()
}
go func() {
for i := 1; i <= 10; i++ {
jobs <- i
}
close(jobs)
}()
sum := 0
for i := 0; i < 10; i++ {
sum += <-results
}
fmt.Println("平方和:", sum)
本机实际输出 平方和: 385,即 1 到 10 的平方和。这段代码能正常结束,是因为主 goroutine 明确知道要收 10 个结果。如果结果数量不固定,就不能用固定次数的循环,要么用 WaitGroup 等所有 worker 结束,要么额外发一个「全部完成」的信号。凭感觉写一个 for range results,很容易永远等下去,因为没有人关闭 results。
worker 数量也不是越多越好。I/O 密集型任务可以多开一些,CPU 密集型任务开到 GOMAXPROCS 附近就够,再多只会增加切换开销。真正的并发上限还要考虑下游:数据库连接池只有 10 个连接,开 100 个 worker 只会让它们在池子门口排队。
worker 里如果可能 panic,要自己 defer recover,否则一个任务出错会让整个进程退出,第 2 篇已经演示过这个边界。任务本身需要超时控制时,把 context 传进 worker,在耗时操作里检查 ctx.Done(),这部分放到下一篇。
需要「任何一个任务失败就取消其余任务」时,标准库没有现成的组合工具,可以自己用 context 加 WaitGroup 实现:每个 worker 检查 ctx,出错时调用 cancel,主流程等所有 worker 结束后返回第一个错误。第三方包 errgroup 把这件事封得更短,但引入它之前先确认团队是否接受额外依赖。
sync 包里其他工具怎么选
除了 Mutex,标准库还有几件常用工具,选错了不会崩,但会慢或者难维护。
RWMutex
读多写少的场景。多个读者可以同时进入,写者独占。适合配置缓存这类「偶尔更新、频繁读取」的数据;如果写也很频繁,读写锁的额外开销可能不如普通 Mutex。
atomic
单个整数或指针的原子操作,适合计数器、标志位。它不能保护「读一个字段再根据它改另一个字段」这种复合逻辑,那种情况仍然要锁。
sync.Once 用来保证某段初始化只执行一次,比如加载配置、建立连接池。它比「先判断标志位再加锁」更简洁,也不会出现两个 goroutine 都判断为「还没初始化」的竞态。sync.Map 适合「键集合基本稳定、读远多于写」的缓存场景,它不是普通 map 的通用替代品;大多数业务里,一把 RWMutex 加普通 map 更直观,也更容易控制失效和清理。
用 Once 时注意它没有返回值,初始化失败后也不会重试。如果初始化可能失败,通常要在 Once 里记录错误,或者改用显式的状态机,别让第一次失败把后续所有调用都永远卡在「已执行过一次」的状态。
还有一个不需要 sync 的场景:数据只属于一个 goroutine。如果每个 goroutine 操作自己的局部变量,最后通过 channel 把结果传出去,就根本不需要锁。并发设计的第一原则是「能不共享就不共享」,减少共享比调优锁更容易。
选择顺序可以简单记成:先问「能不能不共享」,不能就选 channel 传递所有权,再不能才加锁;锁内部如果只是单个计数器,考虑 atomic;读多写少再考虑 RWMutex。每往下一步,代码复杂度都会增加,收益要用实测来证明。
出问题时先看哪里
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 计数偶尔偏小,重跑又正常 | n++ 是非原子的读改写 | 用 -race 跑一次;改成 Mutex 或 atomic |
| WARNING: DATA RACE | 两个 goroutine 无同步地访问同一地址 | 看报告里两处栈的行号;确认它们之间有没有锁或 channel |
| 加了锁结果还是错 | 锁保护的是副本,或锁的范围漏了读写的一侧 | 看接收者是不是指针;看每个共享字段是否都在锁内 |
| 值接收者方法计数为 0 | 结构体连同 Mutex 被复制,改的是副本 | 改成指针接收者;跑 go vet 看 copylocks |
| fatal error: all goroutines are asleep | 所有 goroutine 阻塞,没有外部事件能唤醒 | 看栈里的 chan send/receive;找配对的一方或关闭方 |
| panic: close of closed channel | 同一个 channel 被关闭两次 | 确认关闭方唯一;多个生产者用 WaitGroup 协调 |
| panic: send on closed channel | 关闭后仍有 goroutine 在发送 | 明确所有权,关闭前先停止所有发送者 |
| 主函数结束了但结果不全 | 没有等 WaitGroup,或结果数量算错 | 检查 wg.Wait;检查 results 的接收次数 |
| 读多写少时锁竞争严重 | 普通 Mutex 让所有读者串行 | 评估 RWMutex、atomic 或本地缓存,先测再换 |
排查顺序建议是:先跑 -race,确认有没有数据竞争;再看锁和 channel 的所有权,确认同步机制用对了地方;最后才考虑性能。很多「并发性能问题」其实是锁的范围太大或者 goroutine 泄漏,不是锁本身慢。
边界与代价
- 竞态检测器不能证明没问题:它只报告执行到的路径,覆盖率低的测试可能一条都不报。没报不等于安全,只能说明这次没踩到。
- 锁的粒度是取舍:锁得粗,吞吐下降;锁得细,容易死锁、难维护。先从粗粒度开始,有实测瓶颈再拆,不要一上来就为每个字段配一把锁。
- channel 有容量和阻塞语义:无缓冲适合强同步,有缓冲适合削峰,但缓冲会掩盖消费过慢的问题。容量设为多少,要有依据,不能拍脑袋。
- goroutine 的生命周期要有人负责:起一个 goroutine 很容易,让它退出很难。没有退出条件的 goroutine 就是泄漏,第 2 篇已经演示过数量只涨不降的后果。
- sync.Map 不是银弹:它针对特定访问模式优化,频繁写入、需要遍历、需要原子地「读并更新」的场景,用普通 map 加锁往往更清楚。
- 不要在锁内做 I/O:网络请求、磁盘读写、日志输出都可能阻塞,把临界区拉长几十毫秒,其他 goroutine 全部排队。先把数据取出来,出锁再处理。
并发问题的成本不在写代码,而在验证。一个没有同步的计数器,代码只有一行,排查可能要几天。把「共享数据」标出来、把「谁负责关闭 channel」写清楚、把 -race 放进 CI,这三件事能挡住大部分低级错误。想补操作系统层面的背景,可以看 线程、时间片与调度 那一篇。
当天能自己验证的练习
- 写一百个 goroutine 对同一个 int 自增,用
go run -race运行,记录报告里的两处行号和最后的计数;再改成 Mutex,确认报告消失且结果稳定。 - 把计数器的接收者改成值类型,运行后观察结果是不是 0;再跑
go vet,确认 copylocks 警告出现。 - 写一个无缓冲 channel,主 goroutine 只发送不接收,观察
fatal error: all goroutines are asleep - deadlock!和栈里的[chan send]。 - 对同一个 channel 连续 close 两次,确认第二次 panic;再试一次关闭后发送,确认
send on closed channel。 - 写一个三 worker 的平方计算池,任务发完后关闭 jobs,主 goroutine 收固定数量的结果,确认输出 385;把结果接收次数改成 9,观察程序卡住或结果不对。
小结
三句话收一下:数据竞争来自无同步的共享读写,n++ 不是原子操作,跑得对不代表没问题,要在 CI 里跑 -race;锁保护的是同一份数据,值接收者会把锁一起复制,含锁结构体一律用指针;channel 的发送会阻塞,关闭只能由发送方做一次,重复关闭或关闭后发送都会 panic。
下一篇讲 context。今天你已经看到「卡住」的几种形态,但还没有一个统一的办法让它们停下来:等 channel、等锁、等网络、等子进程,各自都需要一种取消信号。context 就是把这几种等待串成一棵树,并且能在超时或上游取消时,让整棵树一起退出。