来自公众号：Gopher指北

Go内存模型明确指出，一个goroutine如何能力察看到其余goroutine对同一变量的写操作。

当多个goroutine并发同时存取同一个数据时必须把并发的存取操作序列化。在Go中保障读写的序列化能够通过channel通信或者其余同步原语（例如sync包中的互斥锁、读写锁和sync/atomic中的原子操作）。

Happens Before

在单goroutine中，读取和写入的行为肯定是和程序指定的执行程序体现统一。换言之，编译器和处理器在不扭转语言标准所定义的行为前提下才能够对单个goroutine中的指令进行重排序。

a := 1
b := 2
b := 2a := 1
var a, b int
// goroutine A
go func() {
    a := 5
    b := 1
}()
// goroutine B
go func() {
    for b == 1 {}
    fmt.Println(a)
}()
b := 1a := 5

注：上述例子是个不正确的示例，仅作阐明用。

happens before

happens-before的作用

多个goroutine访问共享变量时，它们必须建设同步事件来确保happens-before条件，以此确保读可能察看预期的写。

什么是Happens Before

如果事件e1产生在事件e2之前，那么咱们说e2产生在e1之后。 同样，如果e1不在e2之前产生也没有在e2之后产生，那么咱们说e1和e2同时产生。

在单个goroutine中，happens-before的程序就是程序执行的程序。那happens-before到底是什么程序呢？咱们看看上面的条件。

如果对于一个变量v的读操作r和写操作w满足下述两个条件，r才容许察看到w：

  1. r没有产生在w之前。
  2. 没有其余写操作产生在w之后和r之前。

为了保障变量v的一个读操作r可能察看到一个特定的写操作w，须要确保w是惟一容许被r察看的写操作。那么，如果 r、w 都满足以下条件，r就能确保察看到w：

  1. w产生在r之前。
  2. 其余写操作产生在w之前后者r之后。

单goroutine中不存在并发，这两个条件是等价的。老许在此基础上扩大一下，对于单核心的运行环境这两组条件同样等价。并发状况下，后一组条件比第一组更加严格。

如果你很纳闷，那就对了！老许最开始也很纳闷，这两组条件就是一样的呀。为此老许顺便和原文进行了重复比照确保上述的了解是没有问题的。

咱们换个思路，进行反向推理。如果这两组条件一样，那原文没必要写两次，果然此事并不简略。

在持续剖析之前，要先感激一下我的语文老师，没有你我就无奈发现它们的不同。

r没有产生在w之前
没有其余写操作产生在w之后和r之前

第二组条件就很明确了，w产生在r之前且其余写操作只能产生在w之前或者r之后，如下图（空心示意不可同时）。

到这儿应该明确为什么第二组条件比第一组条件更加严格了吧。在第一组的条件下是容许察看到w，第二组是保障能察看到w。

Go中的同步

上面是Go中约定好的一些同步事件，它们能确保程序遵循happens-before准则，从而使并发的goroutine绝对有序。

Go的初始化

程序初始化运行在单个goroutine中，然而该goroutine能够创立其余并发运行的goroutine。

如果包p导入了包q，则q包init函数执行完结先于p包init函数的执行。main函数的执行产生在所有init函数执行实现之后。

goroutine的创立完结

goroutine的创立先于goroutine的执行。老许感觉这根本就是废话，但事件总是没有那么简略，其隐含之意大略是goroutine的创立是阻塞的。

func sleep() bool {
   time.Sleep(time.Second)
   return true
}

go fmt.Println(sleep())

上述代码会阻塞主goroutine一秒，而后才创立子goroutine。

goroutine的退出是无奈预测的。如果用一个goroutine察看另一个goroutine，请应用锁或者Channel来保障绝对有序。

Channel的发送和接管

Channel通信是goroutine之间同步的次要形式。

  • Channel的发送动作先于相应的承受动作实现之前。
  • 无缓冲Channel的承受先于该Channel上的发送实现之前。
开始发送开始承受发送实现承受实现
开始发送 > 承受实现
开始承受 > 发送实现

留神：开始发送和开始承受并无明确的先后关系

  • Channel的敞开产生在因为通道敞开而返回零值承受之前。
  • 容量为C的Channel第k个承受先于该Channel上的第k+C个发送实现之前。

这里应用极限法应该更加易于了解，如果C为0，k为1则其含意和无缓冲Channel的统一。

Lock

对于任何sync.Mutex或sync.RWMutex变量l以及n < m，第n次l.Unlock()的调用先于第m次l.Lock()的调用返回。

假如n为1，m为2，则第二次调用l.Lock()返回前肯定要先调用l.UnLock()。

对于sync.RWMutex的变量l存在这样一个n，使得l.RLock()的调用返回在第n次l.Unlock()之后产生，而与之匹配的l.RUnlock()产生在第n + 1次l.Lock()之前。

不得不说，下面这句话几乎不是人能了解的。老许将其翻译成人话：

有写锁时：l.RLock()的调用返回产生在l.Unlock()之后。

有读锁时：l.RUnlock()的调用产生在l.Lock()之前。

留神：调用l.RUnlock()前不调用l.RLock()和调用l.Unlock()前不调用l.Lock()会引起panic。

Once

once.Do(f)中f的返回先于任意其余once.Do的返回。

不正确的同步

谬误示范一

var a, b int

func f() {
    a = 1
    b = 2
}

func g() {
    print(b)
    print(a)
}

func main() {
    go f()
    g()
}
b=2a=120
0020

谬误示范二

var a string
var done bool

func setup() {
    a = "hello, world"
    done = true
}

func doprint() {
    if !done {
        once.Do(setup)
    }
    print(a)
}

func twoprint() {
    go doprint()
    go doprint()
}
done = truedone=truea="hello, world"

最初，衷心希望本文可能对各位读者有肯定的帮忙。当然，发现错误也还请及时分割老许改过。

参考

https://golang.org/ref/mem