sync/atomic包提供了底层的原子级内存操作，其执行过程不能被中断，这也就保证了同一时刻一个线程的执行不会被其他线程中断，也保证了多线程下数据操作的一致性。
操作的数据类型共有六种：int32, int64, uint32, uint64, uintptr, unsafe.Pinter，每一种类型又提供了五种操作：Add增减， CompareAndSwap比较并交换， Swap交换， Load载入， Store存储。
函数名以"操作+类型"组合而来。例如AddInt32/AddUint64/LoadInt32/LoadUint64...
以Int32为例：
// AddInt32 atomically adds delta to *addr and returns the new value.
func AddInt32(addr *int32, delta int32) (new int32)
AddInt32可以实现对元素的原子增加或减少，函数会直接在传递的地址上进行修改操作。
addr需要修改的变量的地址，delta修改的差值[正或负数]，返回new修改之后的新值。
var a int32 a += 10 atomic.AddInt32(&a, 10) fmt.Println(a == 20) // true //需要注意的是如果是uint32,unint64时,不能直接传负数，所以需要利用二进制补码机制 var b uint32 b += 20 atomic.AddUint32(&b, ^uint32(10-1)) // 等价于 b -= 10 // atomic.Adduint32(&b, ^uint32(N-1)) //N为需要减少的正整数值 fmt.Println(b == 10) // true
// CompareAndSwapInt32 executes the compare-and-swap operation for an int32 value.
func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)
函数会先判断参数addr指向的值与参数old是否相等，如果相等，则用参数new替换参数addr的值。最后返回swapped是否替换成功。
package main
import (
"fmt"
"sync"
"sync/atomic"
)
func main() {
var c int32
wg := sync.WaitGroup{}
//开启100个goroutine
for i := 0; i < 100; i++ {
wg.Add(1)
go func() {
defer wg.Done()
tmp := atomic.LoadInt32(&c)
if !atomic.CompareAndSwapInt32(&c, tmp, tmp+1) {
fmt.Println("c 修改失败")
}
}()
}
wg.Wait()
//c的值有可能不等于100，频繁修改变量值情况下，CompareAndSwap操作有可能不成功。
fmt.Println("c : ", c)
}
偶尔输出：
//c 修改失败
//c : 99
多数情况下输出
//c : 100
// SwapInt32 atomically stores new into *addr and returns the previous *addr value.
func SwapInt32(addr *int32, new int32) (old int32)
Swap会直接执行赋值操作，并将原值作为返回值返回
package main
import (
"fmt"
"sync"
"sync/atomic"
)
func main() {
var e int32
wg2 := sync.WaitGroup{}
//开启10个goroutine
for i := 0; i < 10; i++ {
wg2.Add(1)
go func() {
defer wg2.Done()
tmp := atomic.LoadInt32(&e)
old := atomic.SwapInt32(&e, tmp + 1)
fmt.Println("e old : ", old)
}()
}
wg2.Wait()
fmt.Println("e : ", e)
}
// e old : 3
// e old : 1
// e old : 2
// e old : 4
// e old : 5
// e old : 6
// e old : 7
// e old : 8
// e old : 9
// e old : 0
// e : 10
// LoadInt32 atomically loads *addr.
func LoadInt32(addr *int32) (val int32)
Load函数参数为需要读取的变量地址，返回值为读取的值
Load和Store操作对应与变量的原子性读写，许多变量的读写无法在一个时钟周期内完成，而此时执行可能会被调度到其他线程，无法保证并发安全。Load只保证读取的不是正在写入的值，Store只保证写入是原子操作。所以在使用的时候要注意。
// StoreInt32 atomically stores val into *addr.
func StoreInt32(addr *int32, val int32)
Store函数参数为需要存储的变量地址及需要写入的值，存储某个值时，任何CPU都不会对该值进行读或写操作，存储操作总会成功，它不关心旧值是什么，与CompareAndSwap不同
var d int32
fmt.Println("d : ", d)
atomic.StoreInt32(&d, 666)
fmt.Println("d : ", d)
文章来源于 https://www.lixiaocheng.com/read/704
有疑问加站长微信联系（非本文作者）
