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-before main.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 中最主要的同步手段,内存模型规定了四条规则:

  1. 对一个 channel 的发送 happens-before 对应的接收完成;
  2. 关闭 channel happens-before 因 channel 已关闭而返回零值的接收;
  3. 对无缓冲 channel 的接收 happens-before 对应的发送完成;
  4. 容量为 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 加进测试流程。