golang内存模型

• 介绍

go内存模型是指在特定的条件下，向goroutine中的变量写入值，在另一个goroutine中能够读取到该变量的值

• 建议

多个goroute同时修改一个数据必须是有序的

使用channel或sync、sync/atomic包中提供的同步原语，可保证对数据顺序访问

• happens before

• 同步

Initialization

程序初始化运行单个goroutine，但这个goroutine可能创建其他同时运行的goroutines。

package p导入package q，q的init方法比p的先执行。

main方法在所有init方法完成初始化后执行

goroutine creation

go声明启动一个goroutine happens before 执行goroutine,示例如下：

var a string

func f() {
        print(a)
}

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

未来可能执行hello方法可能会打印出”hello, world”，目前不会

goroutine destruction

一个goroutine的退出不保证任何事件的执行顺序，示例

var a string

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

给变量a赋值不是一个同步事件，所以不能保证变量a可以被其他goroutine获取到。这段a的赋值操作代码可能在程序编译阶段直接被丢弃掉了。

假如一个goroutine变量值对另一个goroutine可获取到，需要使用锁或信道（channel）通信同步机制保证执行顺序。

Channel communication

goroutines之间的消息同步的主要是通过信道通信（channel）方式实现。在不同的groutine中，每个发送的信道，有个对应的接收信道与其对应。

发送信道happens before接收信道。示例：

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 happens before发送信息至信道c，发送信道happens before从接收信道c中获取信息，接收信息happens before打印动作print.

一个关闭的信道happens before 接收信道，未向信道中发送信息，会返回一个零值，因为信道已经关闭了。可通过替换代码中c<- 0为close(c)代码输出结果是一致的。

下面这段代码类似，使用无缓存的信道通信且变换下发送与接收语句

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 happens before从接收信道c获取数据，从接收信道获取数据happens before从信道c中发送数据，从信道c中发送数据happens before 打印动作Print

假如使用的是缓存信道（如c = make(chan int, 1）)，这段代码不能保证输出“hello, world”。代码可能输出空的字符串，崩溃，或其他。

向一个容量为C的信道发送数据，从该信道接收数据时第k个数据接收happens before 第k+c个数据接收

总结缓存信道通信规则。缓存信道通信方式允许统计信号量：信号量数为活跃使用数，信号量容量为最大活跃使用数，发送数据请求信号量，接收数据释放信号量。这是用于限制并发的常用方法。

下列代码，为work启动一个goroutine，使用了信道限制确保同一时刻最多有三个work在运行。

var limit = make(chan int, 3)

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

Locks

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

变量l为sync.Mutex or sync.RWMutex锁，假如n<m, n调用l.Unlock()返回happens before m调用l.Lock() 返回

示例：

var l sync.Mutex
var a string

func f() {
        a = "hello, world"
        l.Unlock()
}

func main() {
        l.Lock()
        go f()
        l.Lock()
        print(a)
}

var a string
var once sync.Once

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

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

func twoprint() {
        go doprint()
        go doprint()
}

两次执行twoprint方法只会执行setup方法一次。setup方法在所有print方法前执行完成。结果是打印两次“hello, world”

Incorrect synchronization

注意,读操作r可能观察到与读操作r同时发生的写w操作变量值，这并不意味着读操作执行happening after读操作r可以观察到写happened before写操作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 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()
}

在执行doprint方法不能保证输出，观察写数据至变量done，意味着观察写数据至变量a。这个版本的是错误的，可能会输出一个空的字符串，而不是“hello, world”。

另外一种错误是等待一个值，类似：

var a string
var done bool

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

func main() {
        go setup()
        for !done {
        }
        print(a)
}

跟前面的例子一样，这段代码也有可能输出空字符串，观察写数据至变量done，意味着观察写数据至变量a。在两个线程中，没有同步事件用于保证main方法可以观察到写入done变量的值，不能保证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)
}

即使main方法观察到g != nil然后退出循环，还是不能保证main方法可以观察到g.msg的初始化值。

所有的这些错误的例子，表明要从一个gorotine观察到另一个goroutine赋值问题必须使用显式的同步机制。

来源： https://golang.org/ref/mem

关联的部分面试题目

该程序片段输出内容是什么？这种问法是否有误，是否换应该换种思路问：如要输出正确的i值应该怎么处理？

func main() {
    runtime.GOMAXPROCS(1)
    wg := sync.WaitGroup{}
    wg.Add(10)
    for i := 0; i < 10; i++ {
        go func() {
            fmt.Println("A: ", i)
            wg.Done()
        }()
    }
    wg.Wait()
}

该程序片断使用是否有问题？如有如何纠正？

func goRoutineA(a <- chan int) {
    val := <- a
    fmt.Println("goRoutineA received the data", val)
}

func goRoutineB(b <- chan int) {
    val := <- b
    fmt.Println("goRoutineB received the data", val)
}

func main() {
    ch := make(chan int)
    go goRoutineA(ch)
    go goRoutineB(ch)
    ch <- 3
    time.Sleep(time.Second * 1)

}