Go 原子操作

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

本文講解 golang 中 sync.atomic 的常見操作

atomic 提供的原子操作能夠確保任一時刻只有一個goroutine對變數進行操作，善用 atomic 能夠避免程式中出現大量的鎖操作。

atomic常見操作有：

• 增減
• 載入
• 比較並交換
• 交換
• 儲存

下面將分別介紹這些操作。

增減操作

atomic 包中提供了如下以Add為首碼的增減操作:

- func AddInt32(addr *int32, delta int32) (new int32)

- func AddInt64(addr *int64, delta int64) (new int64)

- func AddUint32(addr *uint32, delta uint32) (new uint32)

- func AddUint64(addr *uint64, delta uint64) (new uint64)

- func AddUintptr(addr *uintptr, delta uintptr) (new uintptr)

需要注意的是，第一個參數必須是指標類型的值，通過指標變數可以擷取被運算元在記憶體中的地址，從而施加特殊的CPU指令，確保同一時間只有一個goroutine能夠進行操作。

使用舉例：

package mainimport (    "fmt"    "sync/atomic"    "time")func main() {   var opts int64 = 0   for i := 0; i < 50; i++ {        // 注意第一個參數必須是地址       atomic.AddInt64(&opts, 3) //加操作       //atomic.AddInt64(&opts, -1) 減操作       time.Sleep(time.Millisecond)   }   time.Sleep(time.Second)   fmt.Println("opts: ", atomic.LoadInt64(&opts))}

載入操作

atomic 包中提供了如下以Load為首碼的增減操作:

- func LoadInt32(addr *int32) (val int32)

- func LoadInt64(addr *int64) (val int64)

- func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)

- func LoadUint32(addr *uint32) (val uint32)

- func LoadUint64(addr *uint64) (val uint64)

- func LoadUintptr(addr *uintptr) (val uintptr)

載入操作能夠保證原子的讀變數的值，當讀取的時候，任何其他CPU操作都無法對該變數進行讀寫，其實現機制受到底層硬體的支援。見上述例子中的atomic.LoadInt64(&opts)。

比較並交換

該操作簡稱 CAS(Compare And Swap)。 這類操作的首碼為 CompareAndSwap :

- func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)

- func CompareAndSwapInt64(addr *int64, old, new int64) (swapped bool)

- func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)

- func CompareAndSwapUint32(addr *uint32, old, new uint32) (swapped bool)

- func CompareAndSwapUint64(addr *uint64, old, new uint64) (swapped bool)

- func CompareAndSwapUintptr(addr *uintptr, old, new uintptr) (swapped bool)

該操作在進行交換前首先確保變數的值未被更改，即仍然保持參數 old 所記錄的值，滿足此前提下才進行交換操作。CAS的做法類似操作資料庫時常見的樂觀鎖機制。

需要注意的是，當有大量的goroutine 對變數進行讀寫操作時，可能導致CAS操作無法成功，這時可以利用for迴圈多次嘗試。

使用樣本：

var value int64func atomicAddOp(tmp int64) {for {       oldValue := value       if atomic.CompareAndSwapInt64(&value, oldValue, oldValue+tmp) {           return       }   }}

交換

此類操作的首碼為 Swap：

- func SwapInt32(addr *int32, new int32) (old int32)

- func SwapInt64(addr *int64, new int64) (old int64)

- func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)

- func SwapUint32(addr *uint32, new uint32) (old uint32)

- func SwapUint64(addr *uint64, new uint64) (old uint64)

- func SwapUintptr(addr *uintptr, new uintptr) (old uintptr)

相對於CAS，明顯此類操作更為暴力直接，並不管變數的舊值是否被改變，直接賦予新值然後返回背替換的值。

儲存

此類操作的首碼為 Store：

- func StoreInt32(addr *int32, val int32)

- func StoreInt64(addr *int64, val int64)

- func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer)

- func StoreUint32(addr *uint32, val uint32)

- func StoreUint64(addr *uint64, val uint64)

- func StoreUintptr(addr *uintptr, val uintptr)

此類操作確保了寫變數的原子性，避免其他動作讀到了修改變數過程中的髒資料。

歡迎關注我的個人公眾號： EasyHacking