Go / 系统课时

用 -race 找数据竞争

用 -race 找数据竞争

本节用一个可复现的共享计数器制造数据竞争,再通过 go test -race 阅读报告并修复。你会看到竞态检测器如何指出并发读写位置,以及为什么“最终数值看起来对”也不能证明并发代码安全。

学习目标

  • 用 go test -race 复现并读取数据竞争报告
  • 从读写栈定位共享变量和并发访问路径
  • 用互斥锁或状态归属重新设计共享状态,并再次验证

先复现一个真实竞态

在空目录初始化模块。后续用 -count=1 禁用测试结果缓存,确保每次都重新执行并发代码。

bash
go mod init example.com/racedemo

预期输出

text
go: creating new go.mod: module example.com/racedemo

新建 counter_test.go。四个 goroutine 同时执行 counter++;这条语句包含读、加一、写回,并不是原子操作。WaitGroup 只等待 goroutine 结束,并没有保护计数器本身。

go
package racedemo

import (
	"sync"
	"testing"
)

func TestCounterRace(t *testing.T) {
	var counter int
	const workers = 4
	const loops = 10000

	var wg sync.WaitGroup
	wg.Add(workers)

	for i := 0; i < workers; i++ {
		go func() {
			defer wg.Done()
			for j := 0; j < loops; j++ {
				counter++
			}
		}()
	}

	wg.Wait()
	t.Logf("counter=%d", counter)
}

预期结果:普通 go test 可能偶尔得到 40000,也可能得到更小的值;无论数值是否碰巧正确,只要并发访问未同步,-race 都应把它当作缺陷检查。

用竞态检测器读取访问栈

运行下面的命令。-race 会为内存访问插桩;-run 只执行目标测试,-count=1 确保不复用缓存结果。

bash
go test -race -run '^TestCounterRace$' -count=1 -v

预期输出会包含同类信息,地址、文件路径、行号和耗时会变化:

text
=== RUN   TestCounterRace
==================
WARNING: DATA RACE
Read at <ADDRESS> by goroutine <ID>:
  example.com/racedemo.TestCounterRace.func1()
      <PATH>/counter_test.go:<LINE>

Previous write at <ADDRESS> by goroutine <ID>:
  example.com/racedemo.TestCounterRace.func1()
      <PATH>/counter_test.go:<LINE>
==================
--- FAIL: TestCounterRace (<TIME>)
    testing.go:<LINE>: race detected during execution of test
FAIL
exit status 1
FAIL	example.com/racedemo	<TIME>

定位时先看 Read at 与 Previous write at 指向的第一条业务代码栈,再确认两条栈是否访问同一份共享状态。本例两条栈都落在 counter++,因此根因不是 WaitGroup,而是多个 goroutine 对同一个 int 做未同步的读改写。

用互斥锁修复共享状态

将 counter_test.go 替换为下面的实现。把计数器和锁封装进 Counter,让所有读写都经过同一个同步边界;这样调用方不会因为漏写一次 Lock 而重新引入竞态。

go
package racedemo

import (
	"sync"
	"testing"
)

type Counter struct {
	mu sync.Mutex
	n  int
}

func (c *Counter) Inc() {
	c.mu.Lock()
	c.n++
	c.mu.Unlock()
}

func (c *Counter) Value() int {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.n
}

func TestCounterSafe(t *testing.T) {
	var counter Counter
	const workers = 4
	const loops = 10000

	var wg sync.WaitGroup
	wg.Add(workers)

	for i := 0; i < workers; i++ {
		go func() {
			defer wg.Done()
			for j := 0; j < loops; j++ {
				counter.Inc()
			}
		}()
	}

	wg.Wait()

	if got, want := counter.Value(), workers*loops; got != want {
		t.Fatalf("counter = %d, want %d", got, want)
	}
}

预期结果:计数器的读写都受同一把 sync.Mutex 保护,最终值应稳定为 40000,竞态检测器不再报告共享内存冲突。

再次运行:

bash
go test -race -run '^TestCounterSafe$' -count=1 -v

预期输出

text
=== RUN   TestCounterSafe
--- PASS: TestCounterSafe (<TIME>)
PASS
ok  	example.com/racedemo	<TIME>

选择锁、消息传递还是状态归属

修复竞态不只有“加锁”一种方式。若多个 goroutine 必须频繁读写同一小块内存,sync.Mutex 通常最直接;若状态天然由一个 goroutine 顺序处理,例如任务队列或聚合器,可以让其他 goroutine 只通过 channel 发送消息;若数据可按请求或分片独占,则优先拆分状态,减少共享。

场景 更合适的做法 检查点
共享计数、缓存元数据 sync.Mutex 或 sync.RWMutex 所有访问是否经过同一锁协议
单一消费者处理任务 channel + 单 goroutine 持有状态 是否还有旁路直接读写
可按请求拆开的临时数据 每个 goroutine 独占一份 是否把指针意外传给其他 goroutine

不要为了消除报告而在无关位置随意加锁。锁必须保护“同一份共享状态”的完整不变量,否则可能没有数据竞争,却仍然产生业务层面的并发错误。

把 -race 放进验证流程

竞态检测器只能发现“本次执行实际走到”的并发访问,因此测试覆盖不到的路径不会自动被证明安全。提交前可对整个模块执行一次:

bash
go test -race -count=1 ./...

预期输出在全部包通过时类似:

text
ok  	example.com/racedemo	<TIME>

若某个包出现 WARNING: DATA RACE,命令会以失败状态结束。-race 会显著增加运行开销,因此适合本地专项检查和 CI 测试,而不是作为生产二进制的默认运行方式;对高并发代码还应配合压力测试,让更多交错路径真正被执行。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用 -race 找数据竞争

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通