Golang 语言的内存模型

frank Golang语言开发栈

介绍

Go 内存模型可以保证一个 goroutine 可以读取在不同 goroutine 中修改同一指定变量的值。

建议

程序中的一个 goroutine 修改的数据，如果同时有其它 goroutine 读取该数据，则需要保证程序串行化执行。

为了保证程序串行化执行，我们需要使用 channel 通道操作或其他同步原语（例如 sync 和 sync/atomic 包中的原语）来保护数据。

先行发生（Happens Before）

在单个 goroutine 中，读取和写入的行为必须按照程序指定的顺序执行。也就是说，仅当重新排序不会改变语言规范所定义的该 goroutine 中的运行结果时，编译器和处理器才可以对单个 goroutine 中执行的读取和写入进行重新排序。因为此重新排序，一个 goroutine 查看到的执行顺序可能与另一个 goroutine 查看到的执行顺序不同。

例如，如果一个 goroutine 执行 a = 1；b = 2；另一个可能会在 b 的更新值之前查看 b 的更新值。

为了说明读取和写入的要求，Go team 定义了「先行发生（Happens Before）」原则，在 Go 程序中执行内存操作的偏序。如果事件 e1 发生在事件 e2 之前，那么我们说 e2 发生在 e1 之后。同样，如果 e1 不在 e2 之前发生并且在 e2 之后也没有发生，那么我们说 e1 和 e2 并发。

在单个 goroutine 中，先行发生顺序是程序表示的顺序。

如果同时满足以下两个条件，则允许对变量 v 的读操作 r 查看对变量 v 的写操作 w：

r 在 w 之前不会发生。
在 w 之后且在 r 之前没有发生对 v 的其他写操作。

为了保证变量 v 的读取操作 r 查看到对 v 的特定写入操作 w，请确保 w 是唯一允许 r 查看的写入操作。也就是说，如果同时满足以下两个条件，则保证 r 查看到 w：

w 发生在 r 之前。
对共享变量 v 的任何其他写操作都发生在 w 之前或 r 之后。

这对条件比第一对要更加严格。它要求没有其他写入操作与 w 或 r 并发。

在单个 goroutine 中，没有并发性，因此这两个定义是等效的：读取操作 r 查看最近写入操作 w 写入到 v 的值。当多个 goroutine 访问共享变量 v 时，它们必须使用同步事件来建立先行发生条件，确保读取操作可以看到所需的写入操作。

用 v 的类型的零值初始化变量 v 的行为与在内存模型中的写操作相同。

对大于单个机器字的变量的读取和写入，将如同以未指定顺序的多个机器字大小的变量的操作。

同步

初始化：

程序初始化在单个 goroutine 中运行，但是该 goroutine 可能会创建其他并发执行的 goroutine。

如果包 p 导入了包 q，则 q 的 init 函数执行完成，先行发生在任何 p 的 init 函数开始执行之前。

函数 main.main 的开始执行发生在所有 init 函数执行完成之后。

创建 goroutine：

go 关键字启动新 goroutine 先行发生在该 goroutine 的执行开始之前。

例如，在此程序中：

var a string
func f() {  print(a)}
func hello() {  a = "hello, world"  go f()}

调用 hello 函数，会在之后的某个时间（也许在 hello 返回之后）打印 “ hello，world”。

销毁 goroutine：

不能保证 goroutine 的退出会先行发生在程序中的任何事件发生。例如，在此程序中：

var a string
func hello() {  go func() { a = "hello" }()  print(a)}

未使用任何同步事件限制对变量 a 的赋值操作，因此不能保证任何其他 goroutine 都会看到变量 a 的赋值。实际上，激进的编译器可能会删除整个 go 语句。

如果需要保证一个 goroutine 的执行结果，可以通过另一个 goroutine 来查看到，请使用同步机制（例如锁或 channel 通道通信）来建立程序执行的相对顺序。

channel 通信：

channel 通道通信是 goroutine 之间同步的主要方法。通常在不同的 goroutine 中，将特定 channel 通道上的每个发送与该 channel 通道上的相应接收进行匹配。

channel 通道上的发送操作先行发生在该 channel 通道上的相应接收操作完成。

该程序：

var c = make(chan int, 10)var a string
func f() {  a = "hello, world"  c <- 0}
func main() {  go f()  <-c  print(a)}

保证打印 “hello, world”。对 a 的写操作先行发生在对 channel 通道 c 的发送，先行发生在相应的 channel 通道 c 接收完成，先行发生在 print 操作。

channel 通道关闭先行发生在由于 channel 通道关闭而返回零值的接收。

在前面的示例中，用 close(c) 替换 c <- 0 将产生具有相同运行结果的程序。

来自未缓冲通道的接收先行发生在该通道上的发送完成。

该程序（如上所述，但是交换了 send 和 receive 语句并使用了未缓冲的通道）：

var c = make(chan int)var a string
func f() {  a = "hello, world"  <-c}
func main() {  go f()  c <- 0  print(a)}

也保证打印 “hello, world”。对 a 的写操作先行发生在 c 的接收，先行发生在相应的 c 的发送完成，先行发生在 print 操作。

如果通道有缓冲（例如，c = make（chan int，1）），则不能保证程序会打印 “ hello，world”。（它可能会打印空字符串，崩溃或执行其他操作。）

在容量为 C 的通道上的第 k 个接收先行发生在该通道的第 k + C 个发送完成。

该规则将前一个规则推广到缓冲通道。它允许通过缓冲的 channel 通道对计数信号量进行建模：channel 通道中的元素数量对应于活动使用的数量，channel 通道的容量对应于同时使用的最大数量，发送一个元素获取信号量，以及接收元素会释放信号量。这是限制并发性的常见用法。

该程序为 work 列表中的每个条目启动一个 goroutine，但是 goroutine 使用限制通道进行协调，以确保一次最多运行三个 work 函数。

var limit = make(chan int, 3)
func main() {  for _, w := range work {    go func(w func()) {      limit <- 1      w()      <-limit    }(w)  }  select{}}

锁：

sync 包实现了两种锁定数据类型，即 sync.Mutex 和 sync.RWMutex。

对任何的 sync.Mutex 或 sync.RWMutex 变量 l 和 n < m，n 次调用 l.Unlock()先行发生在 m 次 l.Lock() 返回。

该程序：

var l sync.Mutexvar a string
func f() {  a = "hello, world"  l.Unlock()}
func main() {  l.Lock()  go f()  l.Lock()  print(a)}

保证打印 “hello, world”。第一次调用 l.Unlock()（在 f 中）先行发生在第二次调用 l.Lock()（在 main 中），先行发生在 print 操作。

对于 sync.RWMutex 变量 l，任意的函数调用 l.RLock 满足第 n 次 l.RLock 后发生于第 n 次调用 l.Unlock，对应的 l.RUnlock 先行发生于第 n+1 次调用 l.Lock。

Once：

sync 包为 Once 类型的多个 goroutine 提供了一种安全的初始化机制。多个线程可以对于一个特定的 f 执行 Do(f)，但是只有一个线程将运行 f()，而其它线程调用将阻塞直到 f() 返回。

一个调用 Once.Do(f) 的返回先行发生在其它调用 Once.Do(f) 的返回。

在此程序中：

var a stringvar once sync.Once
func setup() {  a = "hello, world"}
func doprint() {  once.Do(setup)  print(a)}
func twoprint() {  go doprint()  go doprint()}

调用 twoprint 将只调用一次 step。setup 先行发生在两次调用 print 操作。结果是 “ hello，world” 将被打印两次。

同步的错误使用示例

注意，读取操作 r 可能会查看到并发执行的写入操作 w 写入的值。即使这样，也不意味着在 r 之后发生的读取操作将查看到在 w 之前发生的写入操作。

在此程序中：

var a, b int
func f() {  a = 1  b = 2}
func g() {  print(b)  print(a)}
func main() {  go f()  g()}

g 可能会先打印 2，然后再打印 0。

这个事实证明一些常见的习惯用法是不正确的。

双重检查锁定是为了避免同步的资源开销。例如，twoprint 程序可能被错误地编写为：

var a stringvar done bool
func setup() {  a = "hello, world"  done = true}
func doprint() {  if !done {    once.Do(setup)  }  print(a)}
func twoprint() {  go doprint()  go doprint()}

但不能保证在 doprint 中看到 done 的写入意味着看到对 a 的写入。此版本的程序可以（不正确）打印一个空字符串，而不是 “ hello，world”。

另一个不正确的习惯用法是忙等待，如：

var a stringvar done bool
func setup() {  a = "hello, world"  done = true}
func main() {  go setup()  for !done {  }  print(a)}

与之前的程序一样，不能保证在 main 上查看到 done 的写入意味着查看到对 a 的写入，因此该程序也可以打印一个空字符串。更糟糕的是，由于两个线程之间没有同步事件，因此无法保证 main 会始终执行写入操作。不能保证 main 中的循环完成。

此示例有一些微妙的改变，例如该程序。

type T struct {  msg string}
var g *T
func setup() {  t := new(T)  t.msg = "hello, world"  g = t}
func main() {  go setup()  for g == nil {  }  print(g.msg)}