一文搞明白golang底层原子级内存操作 的使用（sync atomic包）

        在我们的程序开发中，对于并发的处理一直都是一件很头疼的事情（Rust这种天生无并发困扰的语言除外）， 在go语言中，官方也给我们提供了底层的原子级内存操作，这对于同步算法的实现是非常有用的。

atomic包使用结论

        由于这个包里面定义的一堆函数官方都不推荐使用，所以这个包里面的函数仅作为参考。我们主要搞明白类型定义和使用即可。 这个atomic包里面的类型定义看似一大推，其实归纳起来就8种，分别是 ：Bool, Int32/64, Uint32/64, Pointer, Uintptr, Value ；  还有他们的方法，基本都一样，即 最多也就以下这5个方法：

1. Add对原子数增加的一个增量数据；
2. Store将数据存储到原子中，当这个Store被调用的时候，他的数据是不允许被拷贝的；
3. Load从原子中加载对应的数据；
4. Swap使用新的数据替换就的数据；
5. CompareAndSwap比较和交换数据。

只要你搞明白了上面的5个方法的使用，这个atomic包的使用也就明白了。

原子级内存操作使用示例

以下我们就以 atomic.Int64 类型的使用为例，来说明如何使用， 其他的类型使用都是一样的，不同的类型方法多少而已，只要有的方法实用都是一样的。

直接上测试用例, 看明白这个测试用例也就明白了， 里面都有详细的注释说明。

import (
	"sync/atomic"
	"testing"
)
 
 
// sync atomic数据类型操作使用示例, 单元测试用例
// 其他的另外7种atomic类型的使用和这个都类似,不在赘述!
// @author tekintian 
// @see https://pkg.go.dev/sync/atomic
func TestAtomicType(t *testing.T) {
	// int64类型的原子数,
	//  他对于的类型声明是 type Int64 struct {// contains filtered or unexported fields}
	// 这个地方我们只需要定义就可以,不需要初始化. 其他几种类型也是一样
	var an1 atomic.Int64
	// 定义了变量后,我们就可以操作他对应的5个方法了
	an1.Store(10)     // 把 10存入这个原子变量
	an1.Add(1)        // 增量加1 类似于  10+1
	ret := an1.Load() // Load取出结果,这里ret为 11
	if ret != 11 {
		t.Fatalf("test failed expected 10, got %d", ret)
	} else {
		t.Logf("store 10 add 1 ok, got %d", ret)
	}
	an1.Swap(100) // 使用100对原子数据进行交换, 交换后的结果为100
	if an1.Load() != 100 {
		t.Fatalf("test failed expected to be 100, got %v", an1.Load())
	} else {
		t.Logf("an1.Swap(100) ok, got %d", an1.Load())
	}
	// 比较并交换,这里会拿第一个参数的值和原子数进行比较,
	//  如果第一个参数的值和原子数相等,就会拿第二个参数的值对对原子数进行交换, 否则返回false,不进行交换
	swapped := an1.CompareAndSwap(10, 200) // 第一个参数 10 和当前原子数100比较,不会被交换
	if !swapped {
		t.Logf("atomic data not swapped, now data is %v, but param1 for compare is 10", an1.Load())
	} else {
		t.Fatalf("an1.CompareAndSwap(10, 200) fail, expected 100 got %d", an1.Load())
	}
 
	if an1.CompareAndSwap(100, 200) { // 会被交换
		// 现在原子的数据应该是 200
		t.Logf("atomic data swapped, now data is %v ", an1.Load())
	} else {
		t.Fatalf("atomic data swapped failed: %v", an1.Load())
	}
	/*// 单元测试结果 下面的参数 -v 表示输出测试日志 即 使用t.Log输出的内容
	✗ go test -run=^TestAtomicType$ -v
	=== RUN   TestAtomicType
	    type_val_test.go:43: store 10 add 1 ok, got 11
	    type_val_test.go:49: an1.Swap(100) ok, got 100
	    type_val_test.go:55: atomic data not swapped, now data is 100, but param1 for compare is 10
	    type_val_test.go:62: atomic data swapped, now data is 200
	--- PASS: TestAtomicType (0.00s)
	PASS
	ok      atomic_demo    0.356s
	*/
}

另外2个官方示例就不贴了，原理都一样， 大家有兴趣的话可以自己去瞄瞄 pkg.go.dev/sync/atomic#example-Value-ReadMostly

怎么样，这个看似很神秘，其实也很简单的底层原子级内存操作是不是明白了？

atomic类型定义参考

type Bool
func (x *Bool) CompareAndSwap(old, new bool) (swapped bool)
func (x *Bool) Load() bool
func (x *Bool) Store(val bool)
func (x *Bool) Swap(new bool) (old bool)
type Int32
func (x *Int32) Add(delta int32) (new int32)
func (x *Int32) CompareAndSwap(old, new int32) (swapped bool)
func (x *Int32) Load() int32
func (x *Int32) Store(val int32)
func (x *Int32) Swap(new int32) (old int32)
type Int64
func (x *Int64) Add(delta int64) (new int64)
func (x *Int64) CompareAndSwap(old, new int64) (swapped bool)
func (x *Int64) Load() int64
func (x *Int64) Store(val int64)
func (x *Int64) Swap(new int64) (old int64)
type Pointer
func (x *Pointer[T]) CompareAndSwap(old, new *T) (swapped bool)
func (x *Pointer[T]) Load() *T
func (x *Pointer[T]) Store(val *T)
func (x *Pointer[T]) Swap(new *T) (old *T)
type Uint32
func (x *Uint32) Add(delta uint32) (new uint32)
func (x *Uint32) CompareAndSwap(old, new uint32) (swapped bool)
func (x *Uint32) Load() uint32
func (x *Uint32) Store(val uint32)
func (x *Uint32) Swap(new uint32) (old uint32)
type Uint64
func (x *Uint64) Add(delta uint64) (new uint64)
func (x *Uint64) CompareAndSwap(old, new uint64) (swapped bool)
func (x *Uint64) Load() uint64
func (x *Uint64) Store(val uint64)
func (x *Uint64) Swap(new uint64) (old uint64)
type Uintptr
func (x *Uintptr) Add(delta uintptr) (new uintptr)
func (x *Uintptr) CompareAndSwap(old, new uintptr) (swapped bool)
func (x *Uintptr) Load() uintptr
func (x *Uintptr) Store(val uintptr)
func (x *Uintptr) Swap(new uintptr) (old uintptr)
type Value
func (v *Value) CompareAndSwap(old, new any) (swapped bool)
func (v *Value) Load() (val any)
func (v *Value) Store(val any)
func (v *Value) Swap(new any) (old any)

 atomic函数的定义参考

这个看上去一大堆，其实下面这些个函数的定义官方都不建议使用！ 在手册中你都能看到这样一句话“Consider using the more ergonomic and less error-prone xxx instead.”  都建议你使用更符合人体工程学的且不容易出错的 xxx 方法代替

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)
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)
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)
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)
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)

参考文档 atomic package - sync/atomic - Go Packages