咔叽网单游戏基地

 找回密码
 立即注册

QQ登录

只需一步,快速开始

查看: 25|回复: 0

[Golang] 详解Go内存模型

[复制链接]
  • TA的每日心情
    无聊
    2019-5-27 08:20
  • 签到天数: 4 天

    [LV.2]圆转纯熟

    2万

    主题

    2万

    帖子

    11万

    积分

    帖子管理员

    Rank: 9Rank: 9Rank: 9

    积分
    117944
    发表于 2020-12-19 15:15:12 | 显示全部楼层 |阅读模式
    介绍
    Go 内存模型规定了一些条件,在这些条件下,在一个 goroutine 中读取变量返回的值能够确保是另一个 goroutine 中对该变量写入的值。【翻译这篇文章花费了我 3 个半小时 】
    Happens Before(在…之前发生)
    在一个 goroutine 中,读操作和写操作必须表现地就好像它们是按照程序中指定的顺序执行的。这是因为,在一个 goroutine 中编译器和处理器可能重新安排读和写操作的执行顺序(只要这种乱序执行不改变这个 goroutine 中在语言规范中定义的行为)。
    因为乱序执行的存在,一个 goroutine 观察到的执行顺序可能与另一个 goroutine 观察到的执行顺序不同。 比如,如果一个 goroutine 执行a = 1; b = 2;,另一个 goroutine 可能观察到 b 的值在 a 之前更新。
    为了规定读取和写入的必要条件,我们定义了 happens before (在…之前发生),一个在 Go 程序中执行内存操作的部分顺序。如果事件 e1 发生在事件 e2 之前,那么我们说 e2 发生在 e1 之后。同样,如果 e1 不在 e2 之前发生也不在 e2 之后发生,那么我们说 e1 和 e2 同时发生。
    在一个单独的 goroutine 中,happens-before 顺序就是在程序中的顺序。
    一个对变量 v 的 读操作 r 可以被允许观察到一个对 v 的写操作 w,如果下列条件同时满足:
    r 不在 w 之前发生在 w 之后,r 之前,没有其他对 v 的写入操作 w' 发生。
    为了确保一个对变量 v 的读操作 r 观察到一个对 v 的 写操作 w,必须确保 w 是唯一的 r 允许的写操作。就是说下列条件必须同时满足:
    w 在 r 之前发生任何其他对共享的变量 v 的写操作发生在 w 之前或 r 之后。
    这两个条件比前面两个条件要严格,它要求不能有另外的写操作与 w 或 r 同时发生。
    在一个单独的 goroutine 中,没有并发存在,所以这两种定义是等价的:一个读操作 r 观察到的是最近对 v 的写入操作 w 。当多个 goroutine 访问一个共享的变量 v 时,它们必须使用同步的事件来建立 happens-before 条件来确保读操作观察到预期的写操作。
    在内存模型中,使用零值初始化一个变量的 v 的行为和写操作的行为一样。
    读取和写入超过单个机器字【32 位或 64 位】大小的值的行为和多个无序地操作单个机器字的行为一样。
    同步
    初始化
    程序初始化操作在一个单独的 goroutine 中运行,但是这个 goroutine 可能创建其他并发执行的 goroutines。
    如果包 p 导入了包 q,那么 q 的 init 函数执行完成发生在 p 的任何 init 函数执行之前。
    函数 main.main【也就是 main 函数】 的执行发生在所有的 init 函数完成之后。
    Goroutine 创建
    启动一个新的 goroutine 的 go 语句的执行在这个 goroutine 开始执行前发生。
    比如,在这个程序中:
    1. var a string
    2. func f() {
    3.         print(a) // 后
    4. }
    5. func hello() {
    6.         a = "hello, world"
    7.         go f() // 先
    8. }
    复制代码
    调用 hello 函数将会在之后的某个事件点打印出 “hello, world”。【因为 a = “hello, world” 语句在 go f() 语句之前执行,而 goroutine 执行的函数 f 在 go f() 语句之后执行,a 的值已经初始化了 】
    Goroutine 销毁
    goroutine 的退出不保证发生在程序中的任何事件之前。比如,在这个程序中:
    1. var a string
    2. func hello() {
    3.         go func() { a = "hello" }()
    4.         print(a)
    5. }
    复制代码
    a 的赋值之后没有跟随任何同步事件,所以不能保证其他的 goroutine 能够观察到赋值操作。事实上,一个激进的编译器可能删除掉整个 go 语句。
    如果在一个 goroutine 中赋值的效果必须被另一个 goroutine 观察到,那么使用锁或者管道通信这样的同步机制来建立一个相对的顺序。
    管道通信
    管道通信是在 goroutine 间同步的主要方法。一个管道的发送操作匹配【对应】一个管道的接收操作(通常在另一个 goroutine 中)。
    一个在有缓冲的管道上的发送操作在相应的接收操作完成之前发生。
    这个程序:
    1. var c = make(chan int, 10) // 有缓冲的管道
    2. var a string
    3. func f() {
    4.         a = "hello, world"
    5.         c <- 0 // 发送操作,先
    6. }
    7. func main() {
    8.         go f()
    9.         <-c // 接收操作,后
    10.         print(a)
    11. }
    复制代码
    能够确保输出 “hello, world”。因为对 a 的赋值操作在发送操作前完成,而接收操作在发送操作之后完成。
    关闭一个管道发生在从管道接收一个零值之前。
    在之前的例子中,将 c <- 0 语句替换成 close(c) 效果是一样的。
    一个在无缓冲的管道上的接收操作在相应的发送操作完成之前发生。
    这个程序 (和上面一样,使用无缓冲的管道,调换了发送和接收操作):
    1. var c = make(chan int) // 无缓冲的管道
    2. var a string
    3. func f() {
    4.         a = "hello, world"
    5.         <-c // 接收操作,先
    6. }
    7. func main() {
    8.         go f()
    9.         c <- 0 // 发送操作,后
    10.         print(a)
    11. }
    复制代码
    也会确保输出 “hello, world”。
    如果管道是由缓冲的 (比如, c = make(chan int, 1))那么程序不能够确保输出 "hello, world". (它可能会打印出空字符串、或者崩溃、或者做其他的事)
    在一个容量为 C 的管道上的第 k 个接收操作在第 k+C 个发送操作完成之前发生。
    该规则将前一个规则推广到带缓冲的管道。它允许使用带缓冲的管道实现计数信号量模型:管道中的元素数量对应于正在被使用的数量【信号量的计数】,管道的容量对应于同时使用的最大数量,发送一个元素获取信号量,接收一个元素释放信号量。这是一个限制并发的常见用法。
    下面的程序对工作列表中的每一项启动一个 goroutine 处理,但是使用 limit 管道来确保同一时间内只有 3 个工作函数在运行。
    1. var limit = make(chan int, 3)
    2. func main() {
    3.         for _, w := range work {
    4.                 go func(w func()) {
    5.                         limit <- 1 // 获取信号量
    6.                         w()
    7.                         <-limit // 释放信号量
    8.                 }(w)
    9.         }
    10.         select{}
    11. }
    复制代码

    sync 包实现了两个锁数据类型,sync.Mutex 和 sync.RWMutex 。
    对任何 sync.Mutex 或 sync.RWMutex 类型的变量 l 和 n < m,第 n 个l.Unlock()操作在第 m 个 l.Lock() 操作返回之前发生。
    这个程序:
    1. var l sync.Mutex
    2. var a string
    3. func f() {
    4.         a = "hello, world"
    5.         l.Unlock() // 第一个 Unlock 操作,先
    6. }
    7. func main() {
    8.         l.Lock()
    9.         go f()
    10.         l.Lock() // 第二个 Lock 操作,后
    11.         print(a)
    12. }
    复制代码
    保证会打印出"hello, world"。
    Once
    sync 包提供了 Once 类型,为存在多个 goroutine 时的初始化提供了一种安全的机制。多个线程可以为特定的 f 执行一次 once.Do(f),但是只有一个会运行 f(),其他的调用将会阻塞直到 f() 返回。
    一个从 once.Do(f) 调用的 f()的返回在任何 once.Do(f) 返回之前发生。
    在这个程序中:
    1. var a string
    2. var once sync.Once
    3. func setup() {
    4.         a = "hello, world" // 先
    5. }
    6. func doprint() {
    7.         once.Do(setup)
    8.         print(a) // 后
    9. }
    10. func twoprint() {
    11.         go doprint()
    12.         go doprint()
    13. }
    复制代码
    调用 twoprint 只会调用 setup 一次。setup 函数在调用 print 函数之前完成。结果将会打印两次"hello, world"。
    不正确的同步
    注意到一个读操作 r 可能观察到与它同时发生的写操作w 写入的值。当这种情况发生时,那也不能确保在 r 之后发生的读操作能够观察到在 w 之前发生的写操作。
    在这个程序中:
    1. var a, b int
    2. func f() {
    3.         a = 1
    4.         b = 2
    5. }
    6. func g() {
    7.         print(b)
    8.         print(a)
    9. }
    10. func main() {
    11.         go f()
    12.         g()
    13. }
    复制代码
    可能会发生函数 g 输出 2 然后 0 的情况。【b 的值输出为2,说明已经观察到了 b 的写入操作。但是之后读取 a 的值却为 0,说明没有观察到 b 写入之前的 a 写入操作!不能以为 b 的值是 2,那么 a 的值就一定是 1 !】
    这个事实使一些常见的处理逻辑无效。
    比如,为了避免锁带来的开销,twoprint 那个程序可能会被不正确地写成:
    1. var a string
    2. var done bool
    3. func setup() {
    4.         a = "hello, world"
    5.         done = true
    6. }
    7. func doprint() {
    8.         if !done { // 不正确!
    9.                 once.Do(setup)
    10.         }
    11.         print(a)
    12. }
    13. func twoprint() {
    14.         go doprint()
    15.         go doprint()
    16. }
    复制代码
    这样写不能保证在 doprint 中观察到了对 done 的写入。这个版本可能会不正确地输出空串。
    另一个不正确的代码逻辑是循环等待一个值改变:
    1. var a string
    2. var done bool
    3. func setup() {
    4.         a = "hello, world"
    5.         done = true
    6. }
    7. func main() {
    8.         go setup()
    9.         for !done { // 不正确!
    10.         }
    11.         print(a)
    12. }
    复制代码
    和之前一样,在 main 中,观察到了对 done 的写入并不意味着观察到了对 a 的写入,所以这个程序可能也会打印一个空串。更糟糕的是,不能够保证对 done 的写入会被 main 观察到,因为两个线程间没有同步事件。 在 main 中的循环不能确保会完成。
    类似的程序如下:
    1. type T struct {
    2.         msg string
    3. }
    4. var g *T
    5. func setup() {
    6.         t := new(T)
    7.         t.msg = "hello, world"
    8.         g = t
    9. }
    10. func main() {
    11.         go setup()
    12.         for g == nil { // 不正确
    13.         }
    14.         print(g.msg)
    15. }
    复制代码
    即使 main 观察到了 g != nil,退出了循环,也不能确保它观察到了 g.msg 的初始值。
    在所有这些例子中,解决方法都是相同的:使用显示地同步。
    到此这篇关于Go 内存模型的文章就介绍到这了,更多相关Go 内存模型内容请搜索咔叽论坛以前的文章或继续浏览下面的相关文章希望大家以后多多支持咔叽论坛!

    原文地址:https://www.jb51.net/article/201661.htm
    回复

    使用道具 举报

    QQ|免责声明|手机版|咔叽网单

    GMT+8, 2021-3-3 03:57

    Powered by Discuz! X3.4

    Copyright © 2001-2020, Tencent Cloud.

    快速回复 返回顶部 返回列表