01. 内存模型
Go 内存模型(The Go Memory Model)回答的是一个问题:一个 goroutine 写入的变量,在什么条件下能保证被另一个 goroutine 读到?
现代 CPU 有多级缓存、写缓冲,编译器和 CPU 都会对指令重排序,所以"代码里先写后读"并不等于"另一个核心先看到写再看到读"。内存模型就是语言给出的一份契约:只要按它规定的方式同步,程序的行为就是可预期的。
官方文档开篇的建议非常直白:
If you must read the rest of this document to understand the behavior of your program, you are being too clever. Don’t be clever.
也就是说,日常开发只需要记住:多个 goroutine 访问共享数据,且至少有一个是写操作时,必须用 channel、sync 包或 sync/atomic 同步。
1.1 happens-before 关系
happens-before 是内存模型的核心概念:
- 如果事件 e1 happens-before e2,那么 e1 的结果(比如对变量的写)对 e2 一定可见;
- 如果 e1 和 e2 之间没有 happens-before 关系,就称它们是并发的,谁先谁后、能否看见都没有保证。
在单个 goroutine 内,happens-before 顺序就是程序代码表达的顺序(编译器可以重排,但不能改变单 goroutine 内可观察到的结果)。
跨 goroutine 的 happens-before 只能通过同步操作建立。下面这个例子就是错误的:
var a string
var done bool
func setup() {
a = "hello, world"
done = true
}
func main() {
go setup()
for !done { // 数据竞争:读 done 与写 done 之间没有同步
}
print(a) // 可能打印空字符串,循环甚至可能永远不退出
}
即使 main 观察到了 done == true,也不保证能看到 a 的写入;更糟的是编译器可能把 done 的读取提到循环外,导致死循环。
数据竞争与 DRF-SC
数据竞争(data race)的定义:两个 goroutine 并发访问同一内存位置,且至少一个是写,且不是都通过 sync/atomic 完成。
Go 1.19 修订后的内存模型明确了 DRF-SC 保证:没有数据竞争的程序,其行为等价于所有 goroutine 的操作按某种顺序交错执行(顺序一致性)。所以只要消灭数据竞争,就不需要考虑重排序这些底层细节。
1.2 Go 语言内置的同步点
初始化
- 如果包 p 导入了包 q,q 的
init函数执行完毕 happens-before p 的任何代码开始; - 所有
init函数完成 happens-beforemain.main开始。
goroutine 的创建与退出
var a string
func f() { print(a) }
func hello() {
a = "hello, world"
go f() // go 语句 happens-before 新 goroutine 开始执行,所以 f 一定能看到 a
}
但 goroutine 的退出不与任何事件同步:
func hello() {
go func() { a = "hello" }()
print(a) // 没有任何保证,需要 channel/WaitGroup 等待
}
1.3 channel 的保证
channel 是 Go 中最主要的同步手段,内存模型规定了四条规则:
- 对一个 channel 的发送 happens-before 对应的接收完成;
- 关闭 channel happens-before 因 channel 已关闭而返回零值的接收;
- 对无缓冲 channel 的接收 happens-before 对应的发送完成;
- 容量为 C 的 channel,第 k 次接收 happens-before 第 k+C 次发送完成。
var a string
var c = make(chan int, 10)
func f() {
a = "hello, world"
c <- 0 // 也可以换成 close(c)
}
func main() {
go f()
<-c
print(a) // 一定打印 hello, world
}
规则 4 是用带缓冲 channel 做信号量限流的理论依据:
var limit = make(chan struct{}, 3)
func main() {
for _, w := range work {
go func(w func()) {
limit <- struct{}{} // 同时最多 3 个任务在执行
w()
<-limit
}(w)
}
select {}
}
1.4 sync 包的保证
| 原语 | 保证 |
|---|---|
sync.Mutex / RWMutex |
第 n 次 Unlock happens-before 第 m 次 Lock 返回(n < m);RWMutex 的 RUnlock 与后续 Lock 同理 |
sync.Once |
once.Do(f) 中 f 的执行完成 happens-before 任何 once.Do 返回 |
sync.WaitGroup |
Done happens-before 被它解除阻塞的 Wait 返回 |
sync.Cond |
配合 Mutex 使用,Wait 返回时重新持有锁 |
互斥锁示例:
var l sync.Mutex
var a string
func f() {
a = "hello, world"
l.Unlock()
}
func main() {
l.Lock()
go f()
l.Lock() // 第二次 Lock 在 f 的 Unlock 之后返回
print(a) // 一定能看到写入
}
sync.Once 实现单例:
var (
instance *Config
once sync.Once
)
func GetConfig() *Config {
once.Do(func() {
instance = loadConfig()
})
return instance // 所有调用者都能看到完整初始化后的 instance
}
1.5 sync/atomic
Go 1.19 起内存模型明确规定:所有 atomic 操作表现为顺序一致(sequentially consistent)。如果原子操作 A 的效果被原子操作 B 观察到,那么 A happens-before B。这和 C++ 的 memory_order_seq_cst、Java 的 volatile 语义类似。
Go 1.19 还新增了类型化的原子类型,推荐优先使用,不容易误用:
type Server struct {
reqs atomic.Int64
ready atomic.Bool
config atomic.Pointer[Config]
}
func (s *Server) Handle() {
s.reqs.Add(1)
if !s.ready.Load() {
return
}
cfg := s.config.Load() // 配置热更新:写方用 Store 整体替换指针
_ = cfg
}
注意:atomic 只保证单个变量操作的原子性。需要多个变量一起保持一致时,应该用 Mutex,或者把它们放进一个不可变结构体,用 atomic.Pointer 整体替换。
1.6 用 -race 检测数据竞争
Go 自带竞态检测器(基于 ThreadSanitizer):
go test -race ./...
go run -race main.go
go build -race -o app .
func main() {
m := map[string]int{}
go func() { m["a"] = 1 }()
m["b"] = 2
time.Sleep(time.Second)
}
运行 go run -race 会输出 WARNING: DATA RACE,并给出两处冲突访问的调用栈。
需要注意:
- race detector 只能发现实际执行到的竞争,测试覆盖不到的路径发现不了;
- 开启后程序的内存和 CPU 开销明显变大,适合测试环境和 CI,一般不在生产常开;
- 并发读写 map 即使不开
-race,运行时也可能直接fatal error: concurrent map writes。
1.7 常见错误
双重检查锁(double-checked locking)
var a string
var done bool
var mu sync.Mutex
func doprint() {
if !done { // 错误:无锁读 done,与下面的写构成数据竞争
mu.Lock()
if !done {
a = "hello, world"
done = true
}
mu.Unlock()
}
print(a) // 看到 done == true 不代表能看到 a 的写入
}
在 Go 中直接使用 sync.Once 即可,它内部已经用 atomic + Mutex 正确实现了快速路径。
忙等待一个普通变量
for !done {} // 错误:没有同步,可能死循环
改为 channel、sync.WaitGroup,或者至少用 atomic.Bool。
发布未完全初始化的对象
var g *T
func setup() {
t := new(T)
t.msg = "hello"
g = t // 普通写指针,另一个 goroutine 可能看到 g != nil 但 g.msg 为空
}
用 atomic.Pointer[T] 发布,或者用 channel 传递指针。
以为"字长内的读写天然原子"就够了
即使某个平台上 int 的读写不会撕裂,没有同步依然不能保证可见性和顺序,而且仍然是数据竞争,-race 会报。
把 time.Sleep 当同步
Sleep 只是"大概率"等到对方执行完,不建立任何 happens-before 关系。
1.8 面试要点
- 什么是 happens-before? 描述跨 goroutine 写对读可见的偏序关系,没有这层关系的两个操作就是并发的。
- channel 为什么能保证可见性? 内存模型规定发送 happens-before 对应接收完成,关闭 happens-before 读到零值的接收。
- atomic 和 Mutex 怎么选? 单个计数器、标志位、指针替换用 atomic;涉及多个变量的不变式用 Mutex。
- Go 的 atomic 是什么内存序? 顺序一致(Go 1.19 起写入内存模型文档)。
- 如何发现数据竞争?
go test -race,并放到 CI 中执行。
小结
- 内存模型的核心是 happens-before:没有同步,就没有可见性保证;
- 同步手段:
go语句、channel 发送/接收/关闭、Mutex、Once、WaitGroup、atomic; - 没有数据竞争的程序表现为顺序一致(DRF-SC),所以重点是消灭数据竞争;
- 不要自己写双重检查锁或忙等标志位,用
sync.Once、channel、atomic.Xxx类型; - 把
-race加进测试流程。