有些朋友可能沒有注意過，在 Go(甚至是大部分語言)中，一條普通的賦值語句其實不是一個原子操作。例如，在32位機器上寫int64類型的變量就會有中間狀態，因為它會被拆成兩次寫操作(匯編的MOV指令)——寫低 32 位和寫高 32 位，如下圖所示：

32機器上對int64進行賦值

如果一個線程剛寫完低32位，還沒來得及寫高32位時，另一個線程讀取了這個變量，那它得到的就是一個毫無邏輯的中間變量，這很有可能使我們的程序出現Bug。

這還只是一個基礎類型，如果我們對一個結構體進行賦值，那它出現并發問題的概率就更高了。很可能寫線程剛寫完一小半的字段，讀線程就來讀取這個變量，那么就只能讀到僅修改了一部分的值。這顯然破壞了變量的完整性，讀出來的值也是完全錯誤的。

面對這種多線程下變量的讀寫問題，Go給出的解決方案是atomic.Value登場了，它使得我們可以不依賴于不保證兼容性的unsafe.Pointer類型，同時又能將任意數據類型的讀寫操作封裝成原子性操作。

之前我在文章Golang 五種原子性操作的用法詳解里，詳細介紹過它的用法，下面我們先來快速回顧一下atomic.Value的使用方式

atomic.Value的使用方式

atomic.Value類型對外提供了兩個讀寫方法：

• v.Store(c) - 寫操作，將原始的變量c存放到一個atomic.Value類型的v里。
• c := v.Load() - 讀操作，從線程安全的v中讀取上一步存放的內容。

下面是一個簡單的例子演示atomic.Value的用法。

1. type Rectangle struct {
2. length int
3. width int
4. }
6. var rect atomic.Value
8. func update(width, length int) {
9. rectLocal := new(Rectangle)
10. rectLocal.width = width
11. rectLocal.length = length
12. rect.Store(rectLocal)
13. }
15. func main() {
16. wg := sync.WaitGroup{}
17. wg.Add(10)
18. // 10 個協程并發更新
19. for i := 0; i < 10; i++ {
20. go func() {
21. defer wg.Done()
22. update(i, i+5)
23. }()
24. }
25. wg.Wait()
26. _r := rect.Load().(*Rectangle)
27. fmt.Printf("rect.width=%d\nrect.length=%d\n", _r.width, _r.length)
28. }

你也可以試試，不用atomic.Value，直接給Rectange類型的指針變量賦值，對比一下兩者結果的區別。

你可能會好奇，為什么atomic.Value在不加鎖的情況下就提供了讀寫變量的線程安全保證，接下來我們就一起看看其內部實現。

atomic.Value的內部實現

atomic.Value被設計用來存儲任意類型的數據，所以它內部的字段是一個interface{}類型。

1. type Value struct {
3. v interface{}
5. }

除了Value外，atomic包內部定義了一個ifaceWords類型，這其實是interface{}的內部表示 (runtime.eface)，它的作用是將interface{}類型分解，得到其原始類型(typ)和真正的值(data)。

1. // ifaceWords is interface{} internal representation.
2. type ifaceWords struct {
3. typ unsafe.Pointer
4. data unsafe.Pointer
5. }

寫入線程安全的保證

在介紹寫入之前，我們先來看一下 Go 語言內部的unsafe.Pointer類型。

unsafe.Pointer

出于安全考慮，Go 語言并不支持直接操作內存，但它的標準庫中又提供一種不安全(不保證向后兼容性) 的指針類型unsafe.Pointer，讓程序可以靈活的操作內存。

unsafe.Pointer的特別之處在于，它可以繞過 Go 語言類型系統的檢查，與任意的指針類型互相轉換。也就是說，如果兩種類型具有相同的內存結構(layout)，我們可以將unsafe.Pointer當做橋梁，讓這兩種類型的指針相互轉換，從而實現同一份內存擁有兩種不同的解讀方式。

比如說，[]byte和string其實內部的存儲結構都是一樣的，他們在運行時類型分別表示為reflect.SliceHeader和reflect.StringHeader

1. type SliceHeader struct {
2. Data uintptr
3. Len int
4. Cap int
5. }
7. type StringHeader struct {
8. Data uintptr
9. Len int
10. }

但 Go 語言的類型系統禁止他倆互換。如果借助unsafe.Pointer，我們就可以實現在零拷貝的情況下，將[]byte數組直接轉換成string類型。

1. bytes := []byte{104, 101, 108, 108, 111}
3. p := unsafe.Pointer(&bytes) //將 *[]byte 指針強制轉換成unsafe.Pointer
4. str := *(*string)(p) //將 unsafe.Pointer再轉換成string類型的指針，再將這個指針的值當做string類型取出來
5. fmt.Println(str) //輸出 "hello"

知道了unsafe.Pointer的作用，我們可以直接來看代碼了：

1. func (v *Value) Store(x interface{}) {
2. if x == nil {
3. panic("sync/atomic: store of nil value into Value")
4. }
5. vp := (*ifaceWords)(unsafe.Pointer(v)) // Old value
6. xp := (*ifaceWords)(unsafe.Pointer(&x)) // New value
7. for {
8. typ := LoadPointer(&vp.typ)
9. if typ == nil {
10. // Attempt to start first store.
11. // Disable preemption so that other goroutines can use
12. // active spin wait to wait for completion; and so that
13. // GC does not see the fake type accidentally.
14. runtime_procPin()
15. if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(^uintptr(0))) {
16. runtime_procUnpin()
17. continue
18. }
19. // Complete first store.
20. StorePointer(&vp.data, xp.data)
21. StorePointer(&vp.typ, xp.typ)
22. runtime_procUnpin()
23. return
24. }
25. if uintptr(typ) == ^uintptr(0) {
26. // First store in progress. Wait.
27. // Since we disable preemption around the first store,
28. // we can wait with active spinning.
29. continue
30. }
31. // First store completed. Check type and overwrite data.
32. if typ != xp.typ {
33. panic("sync/atomic: store of inconsistently typed value into Value")
34. }
35. StorePointer(&vp.data, xp.data)
36. return
37. }
38. }

大概的邏輯：

• 通過unsafe.Pointer將現有的和要寫入的值分別轉成ifaceWords類型，這樣我們下一步就可以得到這兩個interface{}的原始類型(typ)和真正的值(data)。
• 開始就是一個無限 for 循環。配合CompareAndSwap使用，可以達到樂觀鎖的效果。
• 通過LoadPointer這個原子操作拿到當前Value中存儲的類型。下面根據這個類型的不同，分3種情況處理。

第一次寫入 - 一個atomic.Value實例被初始化后，它的typ字段會被設置為指針的零值 nil，所以先判斷如果typ是nil 那就證明這個Value實例還未被寫入過數據。那之后就是一段初始寫入的操作：

• runtime_procPin()這是runtime中的一段函數，一方面它禁止了調度器對當前 goroutine 的搶占(preemption)，使得它在執行當前邏輯的時候不被打斷，以便可以盡快地完成工作，因為別人一直在等待它。另一方面，在禁止搶占期間，GC 線程也無法被啟用，這樣可以防止 GC 線程看到一個莫名其妙的指向^uintptr(0)的類型(這是賦值過程中的中間狀態)。
• 使用CAS操作，先嘗試將typ設置為^uintptr(0)這個中間狀態。如果失敗，則證明已經有別的線程搶先完成了賦值操作，那它就解除搶占鎖，然后重新回到 for 循環第一步。
• 如果設置成功，那證明當前線程搶到了這個"樂觀鎖”，它可以安全的把v設為傳入的新值了。注意，這里是先寫data字段，然后再寫typ字段。因為我們是以typ字段的值作為寫入完成與否的判斷依據的。

第一次寫入還未完成- 如果看到typ字段還是^uintptr(0)這個中間類型，證明剛剛的第一次寫入還沒有完成，所以它會繼續循環，一直等到第一次寫入完成。

第一次寫入已完成 - 首先檢查上一次寫入的類型與這一次要寫入的類型是否一致，如果不一致則拋出異常。反之，則直接把這一次要寫入的值寫入到data字段。

這個邏輯的主要思想就是，為了完成多個字段的原子性寫入，我們可以抓住其中的一個字段，以它的狀態來標志整個原子寫入的狀態。

讀取(Load)操作

先上代碼：

1. func (v *Value) Load() (x interface{}) {
2. vp := (*ifaceWords)(unsafe.Pointer(v))
3. typ := LoadPointer(&vp.typ)
4. if typ == nil || uintptr(typ) == ^uintptr(0) {
5. // First store not yet completed.
6. return nil
7. }
8. data := LoadPointer(&vp.data)
9. xp := (*ifaceWords)(unsafe.Pointer(&x))
10. xp.typ = typ
11. xp.data = data
12. return
13. }

讀取相對就簡單很多了，它有兩個分支：

如果當前的typ是 nil 或者^uintptr(0)，那就證明第一次寫入還沒有開始，或者還沒完成，那就直接返回 nil (不對外暴露中間狀態)。

否則，根據當前看到的typ和data構造出一個新的interface{}返回出去。

總結

本文由淺入深的介紹了atomic.Value的使用姿勢，以及內部實現。讓大家不僅知其然，還能知其所以然。

另外，原子操作由底層硬件支持，對于一個變量更新的保護，原子操作通常會更有效率，并且更能利用計算機多核的優勢，如果要更新的是一個復合對象，則應當使用atomic.Value封裝好的實現。

而我們做并發同步控制常用到的Mutex鎖，則是由操作系統的調度器實現，鎖應當用來保護一段邏輯。

原文鏈接：https://mp.weixin.qq.com/s/GFJO03DFNy8O3HcMeEhT6g