介紹

Go 記憶體模型規定了一些條件，在這些條件下，在一個 goroutine 中讀取變數返回的值能夠確保是另一個 goroutine 中對該變數寫入的值。【翻譯這篇文章花費了我 3 個半小時 】

Happens Before（在…之前發生）

在一個 goroutine 中，讀操作和寫操作必須表現地就好像它們是按照程式中指定的順序執行的。這是因為，在一個 goroutine 中編譯器和處理器可能重新安排讀和寫操作的執行順序（只要這種亂序執行不改變這個 goroutine 中在語言規範中定義的行為）。

因為亂序執行的存在，一個 goroutine 觀察到的執行順序可能與另一個 goroutine 觀察到的執行順序不同。 比如，如果一個 goroutine 執行a = 1; b = 2;

為了規定讀取和寫入的必要條件，我們定義了 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 開始執行前發生。

比如，在這個程式中：

var a string

func f() {
	print(a) // 後
}

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

呼叫 hello 函式將會在之後的某個事件點打印出 “hello,world”。【因為 a = “hello,world” 語句在 go f() 語句之前執行，而 goroutine 執行的函式 f 在 go f() 語句之後執行，a 的值已經初始化了 】

Goroutine 銷燬

goroutine 的退出不保證發生在程式中的任何事件之前。比如，在這個程式中：

var a string

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

a 的賦值之後沒有跟隨任何同步事件，所以不能保證其他的 goroutine 能夠觀察到賦值操作。事實上，一個激進的編譯器可能刪除掉整個 go 語句。

如果在一個 goroutine 中賦值的效果必須被另一個 goroutine 觀察到，那麼使用鎖或者管道通訊這樣的同步機制來建立一個相對的順序。

管道通訊

管道通訊是在 goroutine 間同步的主要方法。一個管道的傳送操作匹配【對應】一個管道的接收操作（通常在另一個 goroutine 中）。

一個在有緩衝的管道上的傳送操作在相應的接收操作完成之前發生。

這個程式：

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 的賦值操作在傳送操作前完成，而接收操作在傳送操作之後完成。

關閉一個管道發生在從管道接收一個零值之前。

在之前的例子中，將 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”。

如果管道是由緩衝的 （比如， c = make(chan int,1)）那麼程式不能夠確保輸出 "hello,world". （它可能會打印出空字串、或者崩潰、或者做其他的事）

在一個容量為 C 的管道上的第 k 個接收操作在第 k+C 個傳送操作完成之前發生。

該規則將前一個規則推廣到帶緩衝的管道。它允許使用帶緩衝的管道實現計數訊號量模型：管道中的元素數量對應於正在被使用的數量【訊號量的計數】，管道的容量對應於同時使用的最大數量，傳送一個元素獲取訊號量，接收一個元素釋放訊號量。這是一個限制併發的常見用法。

下面的程式對工作列表中的每一項啟動一個 goroutine 處理，但是使用 limit 管道來確保同一時間內只有 3 個工作函式在執行。

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.Mutex
var a string

func f() {
	a = "hello,world"
	l.Unlock() // 第一個 Unlock 操作，先
}

func main() {
	l.Lock()
	go f()
	l.Lock() // 第二個 Lock 操作，後
	print(a)
}

保證會打印出"hello,world"。

Once

sync 包提供了 Once 型別，為存在多個 goroutine 時的初始化提供了一種安全的機制。多個執行緒可以為特定的 f 執行一次 once.Do(f)，但是隻有一個會執行 f()，其他的呼叫將會阻塞直到 f() 返回。

一個從 once.Do(f) 呼叫的 f()的返回在任何 once.Do(f) 返回之前發生。

在這個程式中：

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"。

不正確的同步

注意到一個讀操作 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 的情況。【b 的值輸出為2，說明已經觀察到了 b 的寫入操作。但是之後讀取 a 的值卻為 0，說明沒有觀察到 b 寫入之前的 a 寫入操作！不能以為 b 的值是 2，那麼 a 的值就一定是 1 ！】

這個事實使一些常見的處理邏輯無效。

比如，為了避免鎖帶來的開銷，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 的寫入。這個版本可能會不正確地輸出空串。

另一個不正確的程式碼邏輯是迴圈等待一個值改變：

var a string
var done bool

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

func main() {
	go setup()
	for !done { // 不正確！
	}
	print(a)
}

和之前一樣，在 main 中，觀察到了對 done 的寫入並不意味著觀察到了對 a 的寫入，所以這個程式可能也會列印一個空串。更糟糕的是，不能夠保證對 done 的寫入會被 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)
}

即使 main 觀察到了 g != nil，退出了迴圈，也不能確保它觀察到了 g.msg 的初始值。

在所有這些例子中，解決方法都是相同的：使用顯示地同步。

到此這篇關於Go 記憶體模型的文章就介紹到這了,更多相關Go 記憶體模型內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！