介紹
Go 內(nèi)存模型規(guī)定了一些條件，在這些條件下，在一個(gè) goroutine 中讀取變量返回的值能夠確保是另一個(gè) goroutine 中對(duì)該變量寫(xiě)入的值?！痉g這篇文章花費(fèi)了我 3 個(gè)半小時(shí) 】
Happens Before（在…之前發(fā)生）
在一個(gè) goroutine 中，讀操作和寫(xiě)操作必須表現(xiàn)地就好像它們是按照程序中指定的順序執(zhí)行的。這是因?yàn)?，在一個(gè) goroutine 中編譯器和處理器可能重新安排讀和寫(xiě)操作的執(zhí)行順序（只要這種亂序執(zhí)行不改變這個(gè) goroutine 中在語(yǔ)言規(guī)范中定義的行為）。
因?yàn)閬y序執(zhí)行的存在，一個(gè) goroutine 觀察到的執(zhí)行順序可能與另一個(gè) goroutine 觀察到的執(zhí)行順序不同。 比如，如果一個(gè) goroutine 執(zhí)行a = 1; b = 2;，另一個(gè) goroutine 可能觀察到 b 的值在 a 之前更新。
為了規(guī)定讀取和寫(xiě)入的必要條件，我們定義了 happens before （在…之前發(fā)生），一個(gè)在 Go 程序中執(zhí)行內(nèi)存操作的部分順序。如果事件 e1 發(fā)生在事件 e2 之前，那么我們說(shuō) e2 發(fā)生在 e1 之后。同樣，如果 e1 不在 e2 之前發(fā)生也不在 e2 之后發(fā)生，那么我們說(shuō) e1 和 e2 同時(shí)發(fā)生。
在一個(gè)單獨(dú)的 goroutine 中，happens-before 順序就是在程序中的順序。
一個(gè)對(duì)變量 v 的 讀操作 r 可以被允許觀察到一個(gè)對(duì) v 的寫(xiě)操作 w，如果下列條件同時(shí)滿(mǎn)足：
r 不在 w 之前發(fā)生在 w 之后，r 之前，沒(méi)有其他對(duì) v 的寫(xiě)入操作 w' 發(fā)生。
為了確保一個(gè)對(duì)變量 v 的讀操作 r 觀察到一個(gè)對(duì) v 的 寫(xiě)操作 w，必須確保 w 是唯一的 r 允許的寫(xiě)操作。就是說(shuō)下列條件必須同時(shí)滿(mǎn)足：
w 在 r 之前發(fā)生任何其他對(duì)共享的變量 v 的寫(xiě)操作發(fā)生在 w 之前或 r 之后。
這兩個(gè)條件比前面兩個(gè)條件要嚴(yán)格，它要求不能有另外的寫(xiě)操作與 w 或 r 同時(shí)發(fā)生。
在一個(gè)單獨(dú)的 goroutine 中，沒(méi)有并發(fā)存在，所以這兩種定義是等價(jià)的：一個(gè)讀操作 r 觀察到的是最近對(duì) v 的寫(xiě)入操作 w 。當(dāng)多個(gè) goroutine 訪(fǎng)問(wèn)一個(gè)共享的變量 v 時(shí)，它們必須使用同步的事件來(lái)建立 happens-before 條件來(lái)確保讀操作觀察到預(yù)期的寫(xiě)操作。
在內(nèi)存模型中，使用零值初始化一個(gè)變量的 v 的行為和寫(xiě)操作的行為一樣。
讀取和寫(xiě)入超過(guò)單個(gè)機(jī)器字【32 位或 64 位】大小的值的行為和多個(gè)無(wú)序地操作單個(gè)機(jī)器字的行為一樣。
同步
初始化
程序初始化操作在一個(gè)單獨(dú)的 goroutine 中運(yùn)行，但是這個(gè) goroutine 可能創(chuàng)建其他并發(fā)執(zhí)行的 goroutines。
如果包 p 導(dǎo)入了包 q，那么 q 的 init 函數(shù)執(zhí)行完成發(fā)生在 p 的任何 init 函數(shù)執(zhí)行之前。
函數(shù) main.main【也就是 main 函數(shù)】 的執(zhí)行發(fā)生在所有的 init 函數(shù)完成之后。
Goroutine 創(chuàng)建
啟動(dòng)一個(gè)新的 goroutine 的 go 語(yǔ)句的執(zhí)行在這個(gè) goroutine 開(kāi)始執(zhí)行前發(fā)生。
比如，在這個(gè)程序中：
var a string
func f() {
print(a) // 后
}
func hello() {
a = "hello, world"
go f() // 先
}
調(diào)用 hello 函數(shù)將會(huì)在之后的某個(gè)事件點(diǎn)打印出 “hello, world”。【因?yàn)?a = “hello, world” 語(yǔ)句在 go f() 語(yǔ)句之前執(zhí)行，而 goroutine 執(zhí)行的函數(shù) f 在 go f() 語(yǔ)句之后執(zhí)行，a 的值已經(jīng)初始化了 】
Goroutine 銷(xiāo)毀
goroutine 的退出不保證發(fā)生在程序中的任何事件之前。比如，在這個(gè)程序中：
var a string
func hello() {
go func() { a = "hello" }()
print(a)
}
a 的賦值之后沒(méi)有跟隨任何同步事件，所以不能保證其他的 goroutine 能夠觀察到賦值操作。事實(shí)上，一個(gè)激進(jìn)的編譯器可能刪除掉整個(gè) go 語(yǔ)句。
如果在一個(gè) goroutine 中賦值的效果必須被另一個(gè) goroutine 觀察到，那么使用鎖或者管道通信這樣的同步機(jī)制來(lái)建立一個(gè)相對(duì)的順序。
管道通信
管道通信是在 goroutine 間同步的主要方法。一個(gè)管道的發(fā)送操作匹配【對(duì)應(yīng)】一個(gè)管道的接收操作（通常在另一個(gè) goroutine 中）。
一個(gè)在有緩沖的管道上的發(fā)送操作在相應(yīng)的接收操作完成之前發(fā)生。
這個(gè)程序：
var c = make(chan int, 10) // 有緩沖的管道
var a string
func f() {
a = "hello, world"
c - 0 // 發(fā)送操作，先
}
func main() {
go f()
-c // 接收操作，后
print(a)
}
能夠確保輸出 “hello, world”。因?yàn)閷?duì) a 的賦值操作在發(fā)送操作前完成，而接收操作在發(fā)送操作之后完成。
關(guān)閉一個(gè)管道發(fā)生在從管道接收一個(gè)零值之前。
在之前的例子中，將 c - 0 語(yǔ)句替換成 close(c) 效果是一樣的。
一個(gè)在無(wú)緩沖的管道上的接收操作在相應(yīng)的發(fā)送操作完成之前發(fā)生。
這個(gè)程序 （和上面一樣，使用無(wú)緩沖的管道，調(diào)換了發(fā)送和接收操作）：
var c = make(chan int) // 無(wú)緩沖的管道
var a string
func f() {
a = "hello, world"
-c // 接收操作，先
}
func main() {
go f()
c - 0 // 發(fā)送操作，后
print(a)
}
也會(huì)確保輸出 “hello, world”。
如果管道是由緩沖的 （比如， c = make(chan int, 1)）那么程序不能夠確保輸出 "hello, world". （它可能會(huì)打印出空字符串、或者崩潰、或者做其他的事）
在一個(gè)容量為 C 的管道上的第 k 個(gè)接收操作在第 k+C 個(gè)發(fā)送操作完成之前發(fā)生。
該規(guī)則將前一個(gè)規(guī)則推廣到帶緩沖的管道。它允許使用帶緩沖的管道實(shí)現(xiàn)計(jì)數(shù)信號(hào)量模型：管道中的元素?cái)?shù)量對(duì)應(yīng)于正在被使用的數(shù)量【信號(hào)量的計(jì)數(shù)】，管道的容量對(duì)應(yīng)于同時(shí)使用的最大數(shù)量，發(fā)送一個(gè)元素獲取信號(hào)量，接收一個(gè)元素釋放信號(hào)量。這是一個(gè)限制并發(fā)的常見(jiàn)用法。
下面的程序?qū)ぷ髁斜碇械拿恳豁?xiàng)啟動(dòng)一個(gè) goroutine 處理，但是使用 limit 管道來(lái)確保同一時(shí)間內(nèi)只有 3 個(gè)工作函數(shù)在運(yùn)行。
var limit = make(chan int, 3)
func main() {
for _, w := range work {
go func(w func()) {
limit - 1 // 獲取信號(hào)量
w()
-limit // 釋放信號(hào)量
}(w)
}
select{}
}
鎖
sync 包實(shí)現(xiàn)了兩個(gè)鎖數(shù)據(jù)類(lèi)型，sync.Mutex 和 sync.RWMutex 。
對(duì)任何 sync.Mutex 或 sync.RWMutex 類(lèi)型的變量 l 和 n m，第 n 個(gè)l.Unlock()操作在第 m 個(gè) l.Lock() 操作返回之前發(fā)生。
這個(gè)程序：
var l sync.Mutex
var a string
func f() {
a = "hello, world"
l.Unlock() // 第一個(gè) Unlock 操作，先
}
func main() {
l.Lock()
go f()
l.Lock() // 第二個(gè) Lock 操作，后
print(a)
}
保證會(huì)打印出"hello, world"。
Once
sync 包提供了 Once 類(lèi)型，為存在多個(gè) goroutine 時(shí)的初始化提供了一種安全的機(jī)制。多個(gè)線(xiàn)程可以為特定的 f 執(zhí)行一次 once.Do(f)，但是只有一個(gè)會(huì)運(yùn)行 f()，其他的調(diào)用將會(huì)阻塞直到 f() 返回。
一個(gè)從 once.Do(f) 調(diào)用的 f()的返回在任何 once.Do(f) 返回之前發(fā)生。
在這個(gè)程序中：
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()
}
調(diào)用 twoprint 只會(huì)調(diào)用 setup 一次。setup 函數(shù)在調(diào)用 print 函數(shù)之前完成。結(jié)果將會(huì)打印兩次"hello, world"。
不正確的同步
注意到一個(gè)讀操作 r 可能觀察到與它同時(shí)發(fā)生的寫(xiě)操作w 寫(xiě)入的值。當(dāng)這種情況發(fā)生時(shí)，那也不能確保在 r 之后發(fā)生的讀操作能夠觀察到在 w 之前發(fā)生的寫(xiě)操作。
在這個(gè)程序中：
var a, b int
func f() {
a = 1
b = 2
}
func g() {
print(b)
print(a)
}
func main() {
go f()
g()
}
可能會(huì)發(fā)生函數(shù) g 輸出 2 然后 0 的情況。【b 的值輸出為2，說(shuō)明已經(jīng)觀察到了 b 的寫(xiě)入操作。但是之后讀取 a 的值卻為 0，說(shuō)明沒(méi)有觀察到 b 寫(xiě)入之前的 a 寫(xiě)入操作！不能以為 b 的值是 2，那么 a 的值就一定是 1 ！】
這個(gè)事實(shí)使一些常見(jiàn)的處理邏輯無(wú)效。
比如，為了避免鎖帶來(lái)的開(kāi)銷(xiāo)，twoprint 那個(gè)程序可能會(huì)被不正確地寫(xiě)成：
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()
}
這樣寫(xiě)不能保證在 doprint 中觀察到了對(duì) done 的寫(xiě)入。這個(gè)版本可能會(huì)不正確地輸出空串。
另一個(gè)不正確的代碼邏輯是循環(huán)等待一個(gè)值改變：
var a string
var done bool
func setup() {
a = "hello, world"
done = true
}
func main() {
go setup()
for !done { // 不正確！
}
print(a)
}
和之前一樣，在 main 中，觀察到了對(duì) done 的寫(xiě)入并不意味著觀察到了對(duì) a 的寫(xiě)入，所以這個(gè)程序可能也會(huì)打印一個(gè)空串。更糟糕的是，不能夠保證對(duì) done 的寫(xiě)入會(huì)被 main 觀察到，因?yàn)閮蓚€(gè)線(xiàn)程間沒(méi)有同步事件。 在 main 中的循環(huán)不能確保會(huì)完成。
類(lèi)似的程序如下：
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，退出了循環(huán)，也不能確保它觀察到了 g.msg 的初始值。
在所有這些例子中，解決方法都是相同的：使用顯示地同步。
到此這篇關(guān)于Go 內(nèi)存模型的文章就介紹到這了,更多相關(guān)Go 內(nèi)存模型內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
