go 的并发内存模型通过“happens-before”原则确保操作的可见性和顺序。1. 同一个 goroutine 中代码顺序即 happens-before 顺序；2. channel 发送 happens-before 接收；3. mutex.unlock happens-before 下一次 lock；4. sync.once 保证初始化完成前的操作对所有后续访问可见；5. 原子操作提供同步保障。若未显式建立该关系，则可能因重排导致行为不确定。
Golang 的并发内存模型和大多数现代编程语言类似，基于“happens-before”原则来定义多个 goroutine 之间操作的可见性与顺序。简单来说，Go 不保证多 goroutine 下变量读写的顺序一致性，除非你通过 channel、sync 包或者原子操作明确建立 happens-before 关系。
什么是 happens-before 原则？
happens-before 是一种逻辑关系，用来描述两个操作之间的执行顺序和可见性。如果操作 A happens-before 操作 B，那么 A 的结果对 B 是可见的，并且 A 的执行在 B 之前完成。
Go 内存模型中有一些默认规则，比如：
立即学习“go语言免费学习笔记（深入）”；
- 同一个 goroutine 中的语句是按代码顺序（program order）执行的。
- 如果 A 同步于（synchronizes with）B，那么 A happens-before B。
- happens-before 具有传递性：A happens-before B，B happens-before C，则 A happens-before C。
这个原则的核心在于，只有建立了 happens-before 关系的操作之间才有顺序保障和数据可见性保障，否则可能被编译器或 CPU 重排。
Go 中如何建立 happens-before 关系？
Go 提供了几种方式可以显式地建立 happens-before 关系，确保并发安全：
1. 使用 channel 发送/接收操作
channel 是 Go 最推荐的方式之一。发送操作 happens-before 对应的接收操作：
c := make(chan int)
var a string
go func() {
a = "hello"
c <- 0 // 发送
}()
<-c // 接收
println(a) // 能正确输出 hello在这个例子中，
a = "hello"happens-before
<-c，所以
println(a)能看到更新。
2. sync.Mutex 或 sync.RWMutex
加锁和解锁操作之间也建立了 happens-before 关系：
- 在 Mutex.Unlock() 之前的所有写操作，在下一次 Mutex.Lock() 之后都可见。
var mu sync.Mutex
var x int
go func() {
mu.Lock()
x++
mu.Unlock()
}()
go func() {
mu.Lock()
fmt.Println(x) // 可以看到上面的 ++x
mu.Unlock()
}()3. sync.Once
用于只执行一次的初始化操作，内部已经封装了同步机制。
var once sync.Once
var result string
func initResult() {
result = "initialized"
}
once.Do(initResult)无论多少个 goroutine 同时调用
once.Do()，initResult 只会被执行一次，并且所有后续访问都能看到它的效果。
4. 使用 atomic 包进行原子操作
atomic.Load 和 atomic.Store 等操作提供了同步保障，适用于一些简单的并发场景。
为什么不能依赖变量顺序执行？
很多人初学并发时会误以为如下代码是线程安全的：
var a, b int
go func() {
a = 1
b = 2
}()
go func() {
if b == 2 {
fmt.Println(a) // 可能为 0！
}
}()这里的问题是：虽然看起来先写了 a 再写 b，但由于没有建立 happens-before 关系，CPU 或编译器可能会重排这两个赋值操作。因此，即使
b == 2成立，也不能保证
a == 1。
小结一下
Go 的并发内存模型并不提供全局顺序一致性，而是靠开发者手动建立 happens-before 来保证可见性和顺序。常见的手段包括使用 channel、sync.Mutex、Once、atomic 操作等。如果不小心处理，很容易写出看似合理但行为不确定的代码。
基本上就这些。
