大家好,我是江湖十年。

go test -race 是 Go 的数据竞争检测器。在并发代码比较多的项目里,它经常被打开,但也经常被误解:打开它,测试可能突然变慢很多;关掉它,线上又可能冒出莫名其妙的数据错误。

它和 go vet 这类静态检查工具不一样:程序必须真正跑起来,并且实际走到出问题的并发路径,它才能报告。这篇文章就把 data race、happens-before、检测器的工作原理和常见修复方式串起来,回答三个问题:它到底在检测什么?为什么有些并发 bug 它不报?报出来的栈又该怎么看?

本文涉及的全部示例代码,我都放在了 blog-go-example/test/race 目录下,各子目录可单独运行。

先跑一个会报错的程序

从一个最简单的共享计数器开始:

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/counter/main.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import (
"fmt"
"sync"
)

func main() {
var counter int
var wg sync.WaitGroup

wg.Add(2)
go func() {
defer wg.Done()
for i := 0; i < 1000; i++ {
counter++
}
}()
go func() {
defer wg.Done()
for i := 0; i < 1000; i++ {
counter++
}
}()
wg.Wait()
fmt.Println(counter)
}

不用 -race 直接运行,结果可能每次都不一样,也可能碰巧打出 2000。但只要加上 -race:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
$ go run -race main.go
==================
WARNING: DATA RACE
Read at 0x00c000012158 by goroutine 8:
main.main.func2()
./main.go:22 +0x88

Previous write at 0x00c000012158 by goroutine 7:
main.main.func1()
./main.go:16 +0x98

Goroutine 8 (running) created at:
main.main()
./main.go:19 +0x194

Goroutine 7 (running) created at:
main.main()
./main.go:13 +0xfc
==================

实际运行会报多条,这里只截取第一段。这份报告可以拆成四部分:

  • WARNING: DATA RACE:检测到了数据竞争。
  • Read at ... by goroutine 8:当前这次访问,以及它发生在哪个 goroutine。
  • Previous write at ... by goroutine 7:和当前访问冲突的上一次访问。
  • Goroutine ... created at:两个 goroutine 分别在哪里创建。

真正要看的不是地址,而是两份调用栈。它们会把你带到具体代码行:这里两次访问都落在 counter++ 上。

counter++ 看起来是一行,实际上包含“读、加、写”三个动作。两个 goroutine 可能同时读到旧值,再各自写回,最后少加一次。这个问题不是“加锁就完了”这么简单,先要理解它为什么算数据竞争。

data race 与 race condition 不是一回事

Go 内存模型对数据竞争的定义大致是:

两个访问并发地访问同一个内存位置,至少有一次是写,它们之间没有 happens-before 关系,而且不是所有访问都是原子的。

这里的“并发”不是指“同一时刻物理上一起执行”,而是指两个访问没有先后顺序保证,编译器、CPU 可以把它们重排成任意顺序。

数据竞争是内存模型层面的错误。只要存在数据竞争,程序的行为就没有保证,哪怕某次运行结果看起来正常。

但 race condition 的范围更大。它指的是“结果依赖执行时序”的逻辑 bug,不一定伴随数据竞争。比如:

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/racecondition/main.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func withdraw(amount int) bool {
mu.Lock()
ok := balance >= amount
mu.Unlock()

if !ok {
return false
}

mu.Lock()
balance -= amount
mu.Unlock()
return true
}

每次读写 balance 都加了锁,所以 race detector 不会报数据竞争。但“检查余额”和“扣款”不是一个原子操作,两个 goroutine 可能同时通过检查,最后把余额扣成负数。这是 race condition,不是 data race。

反过来,数据竞争也不一定马上表现为业务错误。它可能只是让某个值短暂不一致,也可能在特定编译器版本、特定 CPU 上才出问题。这正是它难查的原因。

再比如 sync.Map 的 Load 之后再 Store:如果没有把这两步合成一个原子操作,两个 goroutine 可能都读到旧值,然后各自覆盖。这不是 data race,race detector 不会报,但它仍然是竞态。

所以 race detector 的定位很明确:它检测 data race,不负责发现死锁、goroutine 泄漏、消息顺序错误,也不负责发现所有逻辑竞态。

理解 happens-before,才能理解为什么有些代码“看起来没事”

Go 内存模型用 happens-before 描述事件之间的顺序。如果事件 A happens-before 事件 B,那么 A 以及 A 之前的内存写入,对 B 都是可见的,而且 A 在逻辑上排在 B 前面。

happens-before 不是 Go 独有的术语。它最早来自 Leslie Lamport 对分布式系统中事件顺序的研究,后来被 Java、C++、Rust、C# 等语言的内存模型采用。Go 内存模型定义的是:在 Go 里,哪些操作能建立这种关系。

它描述的是一种偏序(partial order)。偏序是相对全序(total order)说的:全序能把任意两个事件都排出先后,偏序只能给其中一部分事件排出先后。有些事件有明确顺序,有些事件之间则没有关系。两个事件没有 happens-before 关系,不代表谁一定先发生,只代表它们的顺序没有保证,这正是数据竞争危险的地方。

所以,不要把 happens-before 理解成墙上时钟的“A 先执行”。它保证的是可观察的顺序:如果 A happens-before B,B 就必须看到 A 的结果。至于 CPU 内部指令谁先谁后,只要不破坏这个可观察顺序,都可以重排。

Go 内存模型用两个更基础的关系来定义它:同一 goroutine 里的程序顺序(sequenced before),以及同步操作建立的顺序(synchronized before)。happens-before 是这两个关系的传递闭包。

所谓传递闭包,就是不断套用传递性:如果 A 在 B 之前,B 又在 C 之前,就把 A 在 C 之前也加进来,直到没有新的关系可加为止。这样,同一 goroutine 里的程序顺序,加上 channel、锁等同步操作建立的顺序,就能一路传递到另一个 goroutine 的后续读取。

happens-before 可以传递:如果 A happens-before B,B happens-before C,那么 A 也 happens-before C。不过,它不是墙上时钟的先后。time.Sleep 不会建立 happens-before;两个 goroutine 谁先打印日志,也不代表谁先执行。

Go 里常见的同步关系包括:

  • goroutine 创建:go 语句之前的写入 happens-before 新 goroutine 的开始。
  • channel 发送和接收:发送操作 happens-before 对应的接收完成。
  • channel 关闭:关闭操作 happens-before 因关闭而返回零值的接收。
  • 锁:第 n 次 Unlock happens-before 第 m 次 Lock 返回(n < m)。
  • sync.Once、sync.WaitGroup、sync/atomic 等同步原语也会建立相应的顺序。Go 1.19 修订内存模型后,sync/atomic 的操作按顺序一致(seq-cst)语义处理,和 C++ 的 seq_cst、Java 的 volatile 类似。

注意,goroutine 退出本身不建立 happens-before。一个 goroutine 执行完了,不代表另一个 goroutine 一定能看到它写的数据;必须通过 channel、锁、WaitGroup 等同步操作建立关系。

看一个 channel 的例子:

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/happensbefore/main.go

1
2
3
4
5
6
7
8
9
10
var x int
ch := make(chan struct{})

go func() {
x = 1
ch <- struct{}{}
}()

<-ch
fmt.Println(x) // 一定看到 1

发送 ch <- struct{}{} happens-before 接收 <-ch 完成,所以 x = 1 对主 goroutine 可见。可以把发送看成 release,把接收看成 acquire:发送方在发送之前的写入,对接收方在接收之后的读取可见。

反过来,如果没有 channel 这条同步边,主 goroutine 即使先 time.Sleep 一秒再读 x,也不能保证看到 1。time.Sleep 只改变了墙上时钟,没有建立 happens-before。

如果两个访问之间没有这样的关系,又至少有一个写,就构成数据竞争。

Go 内存模型还有一个重要结论:没有数据竞争的程序,可以表现得像所有 goroutine 都在一个处理器上顺序执行。这就是所谓的 DRF-SC(Data-Race-Free implies Sequential Consistency)。反过来说,一旦有数据竞争,就不要指望程序还保持顺序一致性。

race detector 是怎么工作的

Go 的 race detector 底层用的是 ThreadSanitizer(简称 TSan)。TSan 是一个动态数据竞争检测器,来自 LLVM/compiler-rt,C/C++ 也在用。你可以把它理解成一个在运行时盯着内存访问的检查器:谁读了、谁写了、有没有同步,它都会记下来。它不是一个需要 import 的库,而是“编译器插桩 + 运行时检查”的一套机制。Go 的 -race 就是把 Go 编译器的插桩和 Go 版的 TSan runtime 接了起来。

不需要理解 TSan 的全部实现,只要抓住三件事。

第一,-race 是编译期插桩。编译器会在内存读写前后加入检查代码,同时记录锁、channel、atomic 等同步操作。

第二,运行时维护一份“谁访问了哪块内存”的记录。每次同步操作发生时,它也会记下两个 goroutine 之间的先后关系。

第三,当两次访问同一块内存、至少一次是写,而且运行时找不到它们之间的 happens-before 关系时,就报告 data race。

可以把它想成一个记录员:它不读你的业务代码,只记录内存访问和同步操作,然后沿着这些记录检查有没有“没有同步保护的冲突访问”。

这也解释了它的几个特点:

  • 它是动态检测,只检查程序实际执行到的路径。
  • 它会改变程序时序,可能让某些 race 更容易出现,也可能让某些 race 被掩盖。
  • race 是 happens-before 属性,不是物理上同时执行。即使 GOMAXPROCS=1,只要两个访问之间没有同步关系,也可能被报告。

Go 1.19 升级到 TSan v3 后,检测速度快了不少,内存占用也降低了,但整体开销仍然不小:官方文档给出的数字是执行时间增加 2 到 20 倍,内存增加 5 到 10 倍。

怎么把 -race 用对

最常用的三种方式:

1
2
3
go test -race ./...
go run -race main.go
go build -race -o app

-race 是一个构建标志,不是一个运行时开关。也就是说,只有用 -race 编译出来的程序才带检测能力,普通编译出来的二进制不会因为环境变量就突然开始检查。

几个实用细节:

  • go test -race 会同时启用 checkptr。checkptr 是 Go 编译器的一个检查开关,专门在运行时检查 unsafe.Pointer 的类型转换和指针运算有没有越界、跨对象或对齐不合法,所以它也能顺带发现一些 unsafe 指针问题。
  • -race 会定义 race 构建标签,可以用 //go:build race 写只在检测时启用的代码,或者用 //go:build !race 跳过一些在检测下太慢的测试。
  • 默认检测到 race 后程序会继续运行,最终退出码是 66;go test 会把它当作测试失败。
  • -race 不能和 -msan、-asan 同时使用。-msan 是 MemorySanitizer,查未初始化内存读取;-asan 是 AddressSanitizer,查越界、use-after-free、double free 等地址错误。它们和 race detector 一样需要在编译期插桩,运行时不能叠加;在 Go 里主要是为了和用 ASan/MSan 编译的 C/C++ 代码互操作。
  • 可以用 GORACE 环境变量调整检测器的运行时行为,比如遇到第一个 race 就退出、把报告写到文件、调整退出码,或者增大历史记录以保留更完整的调用栈。它不能提高检测覆盖率,也不能让没执行到的代码被发现。

常用选项:

选项 默认值 作用
log_path stderr 把报告写到文件,实际文件名是 log_path.pid
exitcode 66 检测到 race 后的退出码
strip_path_prefix 空 去掉报告里的路径前缀
history_size 1 控制每个 goroutine 的记录历史,调大可缓解 failed to restore the stack
halt_on_error 0 检测到第一个 race 后是否立即退出
atexit_sleep_ms 1000 退出前等待日志刷盘的毫秒数

例如在 CI 里希望第一个 race 就让任务失败,可以这样跑:

1
GORACE="halt_on_error=1" go test -race ./...

如果报告里出现 failed to restore the stack,通常说明历史记录不够,可以调大 history_size,代价是更多内存。

八类常见的并发问题

1. 共享计数器

最典型的就是 counter++。修复方式有两种:

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/counter/atomic/main.go

1
2
var counter atomic.Int64
counter.Add(1)

或者用锁保护读改写:

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/counter/mutex/main.go

1
2
3
4
5
6
7
8
var (
mu sync.Mutex
counter int
)

mu.Lock()
counter++
mu.Unlock()

简单计数优先用 atomic。atomic.Int64 是 Go 1.19 引入的类型化原子类型,比旧的 atomic.AddInt64(&counter, 1) 更好用。如果一段逻辑要同时保护多个字段,或者读改写本身是一个业务操作,用 mutex 更合适。

2. 并发读写 map

Go 的 map 不是并发安全的。多个 goroutine 同时读写,可能触发 fatal error: concurrent map read and map write,也可能被 race detector 报出来。这是 runtime 直接 fatal,recover 拦不住。即使访问的是不同 key,map 扩容时也可能写同一片内部内存。

完整示例见 map,修复见 map/mutex。

修复方式:

  • 用 sync.Mutex 或 sync.RWMutex 保护整个 map。
  • 读多写少、key 集合相对稳定时,可以考虑 sync.Map。
  • 更好的方式通常是让每个 goroutine 持有自己的局部 map,最后再合并。

不要把 sync.Map 当成默认答案。它的 API 和内存模型都更适合特定场景,普通业务 map 加锁往往更直观。

3. 共享 slice 和 append

slice 变量本身不是一个“数组”,而是一个很小的头部。概念上可以把它看成三个字段:

1
2
3
4
5
type sliceHeader struct {
data unsafe.Pointer // 指向底层数组
len int
cap int
}

标准库里的 reflect.SliceHeader 也是这三个字段,只是 Data 用 uintptr 表示;运行时内部用的是指针。

把 slice 赋值、传参或传给 goroutine 时,复制的是这三个字段,底层数组仍然共享。

所以多个 goroutine 同时对同一个 slice 执行 append,不仅会竞争底层数组,还可能竞争 slice header 本身:一个 goroutine 可能正在改 len、cap,另一个还在读或复制这个 header。只锁 append 不一定够,所有 header 访问都要纳入同一把锁。

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/slice/main.go

1
2
3
4
var results []int
go func() {
results = append(results, 1)
}()

这段代码即使只启动一个 goroutine,只要主 goroutine 同时读 results,也可能构成数据竞争。

常见修复:

  • 用锁保护 append。
  • 每个 goroutine 写入自己的局部 slice,最后统一合并。
  • 通过 channel 把结果交给一个 collector goroutine。

完整修复示例见 slice/mutex。

4. 循环变量捕获

在 Go 1.22 之前,下面这段代码里的 v 是所有迭代共享的:

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/loopvar/main.go

1
2
3
4
5
for _, v := range values {
go func() {
use(v)
}()
}

Go 1.22 改变了循环变量语义,每轮迭代都会创建新的变量,所以这段代码在新版本里不再因为共享 v 而产生数据竞争。是否启用新语义取决于模块 go.mod 里的 go 版本,老模块即使换了新工具链,也可能仍然保留旧行为。

但 Go 1.22 只改了“在 for 循环里用 := 声明”的变量。如果变量是在循环外声明的,比如 var i int,然后在 for 里使用,它仍然只有一份,即使 Go 1.26 也照样会报数据竞争。官方 race detector 文档里的 loop counter 例子就是这种情况:

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/loopvar/main.go

1
2
3
4
5
6
var i int
for i = 0; i < 5; i++ {
go func() {
fmt.Println(i)
}()
}

这段代码通常打印 55555,而不是 01234。修复方式是在启动 goroutine 时把当前值作为参数传进去,或者在循环体里创建局部副本。完整示例见 loopvar/fixed。

另外,如果通过闭包修改外部变量,仍然需要同步。

5. 延迟初始化

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/once/main.go

1
2
3
4
5
6
7
8
var instance *Client

func GetClient() *Client {
if instance == nil {
instance = newClient()
}
return instance
}

两个 goroutine 同时调用 GetClient,可能都看到 nil,创建两个实例,也可能一个看到写了一半的对象。

修复方式:

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/once/fixed/main.go

1
2
3
4
5
6
7
8
9
10
11
var (
once sync.Once
instance *Client
)

func GetClient() *Client {
once.Do(func() {
instance = newClient()
})
return instance
}

Go 1.21 之后还可以用 sync.OnceValue,把初始化逻辑包成一个只执行一次的函数。

6. WaitGroup、close 和生命周期问题

sync.WaitGroup 的常见错误是把 Add 放进 goroutine:

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/waitgroup/main.go

1
2
3
4
5
6
7
8
9
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
go func() {
wg.Add(1) // 错误:可能和 Wait 并发
defer wg.Done()
work()
}()
}
wg.Wait()

Add 应该在启动 goroutine 之前调用。否则 Wait 可能提前返回,主 goroutine 和子 goroutine 再去竞争读写结果。Go 1.25 新增了 WaitGroup.Go,可以自动处理 Add 和 Done(需要 Go 1.25 及以上):

完整示例见 waitgroup/fixed。

1
2
3
4
5
6
7
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Go(func() {
work()
})
}
wg.Wait()

另一个常见问题是关闭 channel 和发送操作之间的竞争:

1
2
3
4
go func() {
ch <- 1
}()
close(ch) // 可能 panic: send on closed channel

这不是数据竞争,而是生命周期和顺序问题。race detector 不一定能报出来,但程序会直接 panic。解决方式是明确谁负责关闭 channel,通常由发送方关闭,或者用 sync.Once、done channel 协调。

7. mutex 按值传递或复制

sync.Mutex 不能按值复制。把包含 mutex 的结构体按值传给函数,或者用值 receiver 定义方法,锁住的都是副本,等于没锁。

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/mutex/main.go

1
2
3
4
5
6
7
8
9
10
type Counter struct {
mu sync.Mutex
n int
}

func (c Counter) Inc() { // 错误:c 是副本
c.mu.Lock()
c.n++
c.mu.Unlock()
}

应该用指针 receiver,也不要按值传递含锁的结构体:

https://github.com/jianghushinian/blog-go-example/blob/main/test/race/mutex/fixed/main.go

1
2
3
4
5
func (c *Counter) Inc() {
c.mu.Lock()
c.n++
c.mu.Unlock()
}

go vet 的 copylocks 会报告这类问题。这个错误很隐蔽,因为代码看起来确实加了锁,只是锁错了对象。

8. 共享 buffer 和对象池复用

共享一个 []byte 或 bytes.Buffer,一个 goroutine 写入时另一个还在读取,就会造成数据损坏。sync.Pool 也有类似风险:如果对象放回池子后仍被其他地方引用,下一次取出的 goroutine 可能复用它。

完整示例见 buffer,修复见 buffer/fixed。

修复思路是明确生命周期:要么每个使用者持有独立 buffer,要么在放回池子前确保没人再引用,取出时彻底重置。不要因为“只是复用一下”就忽略所有权。

真实案例:race 报告不会无缘无故出现

Go 官方博客里有两个经典案例。

第一个是 time.Timer.Reset。代码大致是:

1
2
3
4
var t *time.Timer
t = time.AfterFunc(randomDuration(), func() {
t.Reset(randomDuration())
})

定时器回调里读写 t,主 goroutine 也可能同时访问 t。在某些时序下会触发 nil pointer panic。修复方式是让主 goroutine 单独负责 t 的读写,通过 channel 通知它重置定时器。

第二个是 ioutil.Discard。它的 ReadFrom 方法内部共享了一个 buffer。Go 团队一开始认为所有写入都会被丢弃,这个 race “不重要”,甚至在 race detector 报告后把它当成误报,专门写了一个只在 race 模式启用的无竞争版本。几个月后,Brad 遇到一个诡异的 hash 计算错误,最后发现根因正是这个共享 buffer。

这个案例最值得记住的一点是:race detector 报出来的问题,不要因为“这里看起来无害”就忽略。数据竞争可能不会在你以为的地方出问题,但它会以另一种方式造成破坏。

这不是标准库独有的问题。Uber 在 2022 年曾统计约 5,000 万行 Go 代码、2,100 个服务,在 6 个月里检测到约 2,000 起数据竞争,修复了约 1,100 起。大型开源项目里也有不少典型事故:

  • Kubernetes apiserver 在大量 Pod 删除和 webhook 超时时,审计事件的 Annotations map 被并发写入和编码,触发 fatal error: concurrent map iteration and map write;issue #120507 记录了现场,PR #129472 通过隔离可变状态修复了问题。
  • Prometheus 的矩阵查询把结果 matrix 过早放回 pool,另一个查询复用了同一份数据,导致返回结果串数据;issue #4261 记录了这个案例,最终靠 PromQL 的大改解决。
  • Moby 在同时捕获 stdout/stderr 时,JSON 日志的共享 buffer 被并发写,日志内容交错损坏;issue #43647 描述了问题,PR #43650 给每条日志使用了独立 buffer。

这些案例有共同的模式:共享 map、共享 buffer、对象池复用,都是“看起来只是读一下”的地方。

局限:没报不等于没有

race detector 很有用,但它不是证明工具。

它只能发现实际执行到的数据竞争。如果某条代码路径没有被测试覆盖,或者某个并发时序没有出现,它就不会报。所以“go test -race 通过”只能说明这次执行没有发现 race,不能说明程序没有 race。

其他限制包括:

  • 它检测的是 data race,不是死锁、goroutine 泄漏、消息顺序错误等逻辑问题。
  • 它会显著改变程序时序,可能掩盖一些 race,也可能暴露一些平时不出现的 race。
  • 它依赖插桩,cgo 调用的 C 代码、未用 -race 编译的代码可能不在检测范围内。
  • 它只保留有限的访问历史,旧记录会被覆盖,所以高频访问下可能丢掉关键历史,导致漏报。
  • cgo 调用的 C 代码不在插桩范围内,可能漏报。
  • 原子操作本身不会被报成数据竞争,但原子操作和普通读写混用仍然可能竞争。
  • 它对平台和工具链有要求。32 位平台不支持;非 Darwin 系统通常需要 cgo 和 C 编译器;Windows 需要较新的 mingw-w64 runtime。
  • 它有性能开销。官方当前给出的数字是执行时间 2 到 20 倍,内存 5 到 10 倍。
  • -race 下每个 defer 和 recover 会多分配 8 字节,而且这些内存要等 goroutine 退出才回收,也不会出现在 runtime.ReadMemStats 或 runtime/pprof 里。长生命周期的 goroutine 如果反复 defer/recover,可能导致内存持续增长。

平台和工具链

截至 Go 1.27,race detector 支持 Linux 的 amd64、arm64、loong64、ppc64le、riscv64、s390x,macOS 的 amd64、arm64,以及 FreeBSD、NetBSD、Windows 的 amd64。32 位平台不支持。

在非 Darwin 系统上,-race 通常需要启用 cgo 并安装 C 编译器;Windows 还需要较新的 mingw-w64 runtime。macOS 从 Go 1.20 开始不再需要 cgo 和 Xcode。go help build 里的平台列表可能更新不及时,实际以构建时的检测结果为准。

生产环境怎么用

最现实的做法不是“生产环境全量开 -race”,而是分层使用:

  1. 本地开发时,对并发相关的包跑 go test -race。
  2. CI 里固定跑 go test -race ./...,把它当成必过项。
  3. 集成测试、压力测试、混沌测试优先用 -race 编译,因为这些场景更容易覆盖并发路径;并发测试可以用 -count 多跑几轮,增加命中概率。
  4. 生产环境可以短期、低流量、金丝雀实例开启,但要接受性能和内存开销,并确保日志能收集到。
  5. 对已知的 race 报告,修根因,不要用 suppress 或“看起来没事”糊弄过去。

如果 CI 里希望快速失败:

1
GORACE="halt_on_error=1" go test -race ./...

如果要把报告落盘:

1
GORACE="log_path=/var/log/myapp/race" go test -race ./...

修复优先级和辅助工具

实际修复时,可以先按这个顺序考虑:

  1. 能复制就复制,能明确所有权就明确所有权,避免共享。
  2. 必须共享时,用锁保护完整的业务操作,而不是只保护单次读写。
  3. 简单计数、标志位等场景,用 sync/atomic。
  4. channel 更适合传递数据所有权或事件,不要把它当成“万能锁”。

go vet 也能提前发现一类问题,比如 copylocks 会发现复制了 sync.Mutex、sync.WaitGroup 等包含锁的类型,loopclosure 会检查循环变量捕获,waitgroup 会检查 WaitGroup.Add 的位置。这些检查很快,可以和 -race 配合使用,但它们不能替代 race detector。

一份检查清单

写完并发代码后,可以按这几条自查:

  • 所有共享可变状态,是否都有明确的 owner 或同步方式?
  • 读改写操作,是否用了 mutex、atomic 或 channel 保护?
  • map、slice、结构体字段,是否可能在多个 goroutine 之间共享?
  • 循环变量、闭包捕获的变量,是否真的每轮独立?
  • 含锁的结构体是否被按值传递或复制?
  • WaitGroup.Add 是否在启动 goroutine 之前调用?
  • channel 由谁关闭?关闭时还有没有发送方?
  • 共享 buffer 或 sync.Pool 对象,生命周期是否明确?
  • atomic 操作是否和普通读写混用?
  • 是否把 time.Sleep 当成了同步手段?
  • 并发相关测试是否在 CI 里开了 -race?
  • race 报告是否被当成 bug 处理,而不是当成噪声?

最后

race detector 的价值,不是让你在 CI 里多跑一个命令,而是把“数据竞争”从一个靠运气发现的问题,变成一个可以被工具稳定报告的问题。

它有三个边界值得记住:

  1. 它基于 ThreadSanitizer,编译时插桩、运行时检测。
  2. 它只对实际执行到的路径负责,并且会显著改变性能和时序。
  3. 报出来通常就是 bug,不要因为看起来无害就忽略;没报,不等于没有 race。

把这三句话记住,再配合 go test -race ./...、真实的并发测试和良好的同步设计,race detector 才真正有用。

参考资料

希望此文能对你有所启发。

延伸阅读

联系我