Golang 五种原子性操作的用法详解

一个或者多个操作在 CPU 执行的过程中不被中断的特性，称为原子性（atomicity） 。这些操作对外表现成一个不可分割的整体，他们要么都执行，要么都不执行，外界不会看到他们只执行到一半的状态。

CPU

执行一系列操作时不可能不发生中断，但如果我们在执行多个操作时，能让他们的中间状态对外不可见，那我们就可以宣称他们拥有了"不可分割”的原子性。

类似数据库事务的 ACID

1、Go 语言提供了哪些原子操作

Go语言在设计上对同步（Synchronization，数据同步和线程同步）提供大量的支持，比如 goroutine和channel同步原语，库层面有

• sync：提供基本的同步原语（比如Mutex、RWMutex、Locker）和 工具类（Once、WaitGroup、Cond、Pool、Map）
• sync/atomic：通过内置包 sync/atomic 提供了对原子操作的支持（基于硬件指令 compare-and-swap）

当我们想要对某个变量并发安全的修改，除了使用官方提供的 mutex，还可以使用 sync/atomic 包的原子操作，它能够保证对变量的读取或修改期间不被其他的协程所影响。

atomic 包的原子操作是通过 CPU 指令，也就是在硬件层次去实现的，性能较好，不需要像 mutex 那样记录很多状态。 当然，mutex 不止是对变量的并发控制，更多的是对代码块的并发控制，2 者侧重点不一样。

atomic 这些功能需要非常小心才能正确使用。 除了特殊的低级应用程序外，最好使用通道或同步包的工具来完成同步。 通过通信共享内存； 不要通过共享内存进行通信。

atomic 包有几种原子操作，主要是 Add、CompareAndSwap、Load、Store、Swap

Add

atomic 的 Add 是针对 int 和 uint 进行原子加值的：

当需要添加的值为负数的时候，做减法，正数做加法

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

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

// AddInt64原子地将delta添加到*addr并返回新值。
// 考虑使用更符合人体工程学和更不容易出错的[Int64.Add]
func AddInt64(addr *int64, delta int64) (new int64)

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

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

CompareAndSwap

比较并交换方法实现了类似乐观锁的功能，只有原来的值和传入的 old 值一样，才会去修改,

CAS 操作， 会先比较传入的地址的值是否是 old，如果是的话就尝试赋新值，如果不是的话就直接返回 false，返回 true 时表示赋值成功。

// CompareAndSwapInt32对一个int32值执行比较-交换( compare-and-swap)操作。

//考虑使用更符合人体工程学和更不容易出错的[Int32.CompareAndSwap] 代替.
func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)
func (x *Int32) CompareAndSwap(old, new int32) (swapped bool)


func CompareAndSwapInt64(addr *int64, old, new int64) (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 CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)

需要注意的是，CompareAndSwap 有可能产生ABA现象发生。也就是原来的值是 A，后面被修改 B，再后面修改为 A。在这种情况下也符合了 CompareAndSwap 规则，即使中途有被改动过。

需要注意的是，当有大量的goroutine 对变量进行读写操作时，可能导致CAS
操作无法成功，这时可以利用for 循环多次尝试。

unsafe.Pointer提供了绕过Go语言指针类型限制的方法，unsafe指的并不是说不安全，而是说官方并不保证向后兼容。

Load

从某个地址中取值

Load 方法是为了防止在读取过程中，有其他协程发起修改动作，影响了读取结果，常用于配置项的整个读取。

// LoadInt32 原子地加载 *addr。
// 考虑使用更符合人体工程学和更不容易出错的[Int32.Load] 
func LoadInt32(addr *int32) (val int32)

func LoadInt64(addr *int64) (val int64)

func LoadUint32(addr *uint32) (val uint32)

func LoadUint64(addr *uint64) (val uint64)

func LoadUintptr(addr *uintptr) (val uintptr)

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

Store

给某个地址赋值

// StoreInt32原子地将val存储到*addr中。
// 考虑使用更人性化和更不容易出错的[Int32.Store]。
func StoreInt32(addr *int32, val int32)

func StoreInt64(addr *int64, val int64)

func StoreUint32(addr *uint32, val uint32)

func StoreUint64(addr *uint64, val uint64)

func StoreUintptr(addr *uintptr, val uintptr)

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

Swap

交换两个值，并且返回老的值

Swap 方法实现了对值的原子交换，不仅 int，uint 可以交换，指针也可以。

// SwapInt32 原子地将new存储到 *addr 中，并返回前一个 *addr 值。
// 考虑使用更人性化和更不容易出错的[Int32.Swap]。
func SwapInt32(addr *int32, new int32) (old int32)

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

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

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

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

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

value类型

Value 值用来原子读取和修改任何类型的Go值。

// Value 提供了一致类型值的原子加载和存储。
// Value 的零值从Load返回nil。
// 一旦调用了Store，就不能复制Value。

// Value 在第一次使用后不能复制。
type Value struct {
	v any
}

func (*Value) Load() (x interface{})
func (*Value) Store(x interface{})
func (*Value) Swap(new interface{}) (old interface{})
func (*Value) CompareAndSwap(old, new interface{}) (swapped bool)

值得一提的是如果你想要并发安全的设置一个结构体的多个字段，除了把结构体转换为指针，通过StorePointer设置外，还可以使用atomic
包后来引入的atomic.Value，它在底层为我们完成了从具体指针类型到unsafe.Pointer之间的转换。

有了atomic.Value后，它使得我们可以不依赖于不保证兼容性的unsafe.Pointer类型，同时又能将任意数据类型的读写操作封装成原子性操作（中间状态对外不可见）。

Load()

func (v *Value) Load() (val any)

由于Load() 返回的是一个interface{}类型，所以在使用前我们记得要先转换成具体类型的值，再使用。

Store()

func (v *Value) Store(val any)

Swap()

// Swap将new存储到Value中并返回前一个值。如果Value为空，则返回nil。

// 所有对给定值的Swap调用都必须使用相同具体类型的值。不一致类型的Swap会出
// 现恐慌，Swap(nil)也是如此。
func (v *Value) Swap(new any) (old any)

CompareAndSwap()

func (v *Value) CompareAndSwap(old, new any) (swapped bool) 

// 例子
type Rectangle struct {
 length int
 width  int
}

var rect atomic.Value

func update(width, length int) {
 rectLocal := new(Rectangle)
 rectLocal.width = width
 rectLocal.length = length
 rect.Store(rectLocal)
}

func main() {
 wg := sync.WaitGroup{}
 wg.Add(10)
 // 10 个协程并发更新
 for i := 0; i < 10; i++ {
  go func() {
   defer wg.Done()
   update(i, i+5)
  }()
 }
 wg.Wait()
 _r := rect.Load().(*Rectangle)
 fmt.Printf("rect.width=%d\nrect.length=%d\n", _r.width, _r.length)
}

CAS

在 sync/atomic 包中的源码除了 Value之外其他的函数都是没有直接的源码的，需要去 runtime/internal/atomic 中找寻，这里为 CAS 函数为例，其他的都是大同小异

// bool Cas(int32 *val, int32 old, int32 new)
// Atomically:
//	if(*val == old){
//		*val = new;
//		return 1;
//	} else
//		return 0;
TEXT runtime∕internal∕atomic·Cas(SB),NOSPLIT,$0-17
	MOVQ	ptr+0(FP), BX
	MOVL	old+8(FP), AX
	MOVL	new+12(FP), CX
	LOCK
	CMPXCHGL	CX, 0(BX)
	SETEQ	ret+16(FP)
	RET

在注释部分写的非常清楚，这个函数主要就是先比较一下当前传入的地址的值是否和 old 值相等，如果相等，就赋值新值返回 true，如果不相等就返回 false

我们看这个具体汇编代码就可以发现，使用了LOCK 来保证操作的原子性，CMPXCHG 指令其实就是 CPU 实现的 CAS 操作。

var (
	x  int64
	mx sync.Mutex
	wg sync.WaitGroup
)

// 普通函数， 并发不安全
func Add() {
	x++
	wg.Done()
}

// 互斥锁, 并发安全，性能低于原子操作
func MxAdd() {
	mx.Lock()
	x++
	mx.Unlock()
	wg.Done()
}

// 原子操作，并发安全，性能高于互斥锁，只针对go中的一些基本数据类型使用
func AmAdd() {
	atomic.AddInt64(&x, 1)
	wg.Done()
}

func main() {
	// 原子操作atomic包
	// 加锁操作涉及到内核态的上下文切换， 比较耗时，代价高
	// 针对基本数据类型我们还可以使用原子操作来保证并发安全
	// 因为原子操作是go语言提供的方法，我们在用户态就可以完成，因此性能比加锁操作更好
	// go语言的原子操作由内置的库,sync/atomic完成

	start := time.Now()
	for i := 0; i < 10000; i++ {
		wg.Add(1)
		go Add() // 普通版Add函数不是并发安全的
		//go MxAdd() // 加锁版Add函数，是并发安全的, 但是加锁性能开销大
		//go AmAdd() // 原子操作版Add函数，是并发安全的，性能优于加锁版
	}

	end := time.Now()
	wg.Wait()
	fmt.Println(x)
	fmt.Println(end.Sub(start))

}

互斥锁跟原子操作的区别

• 使用目的：互斥锁是用来保护一段逻辑，原子操作用于对一个变量的更新保护。

• 底层实现：
  Mutex 由操作系统的调度器实现，
  而 atomic 包中的原子操作则由底层硬件指令直接提供支持，这些指令在执行的过程中是不允许中断的，因此原子操作可以在 lock-free（无锁并发） 的情况下保证并发安全，并且它的性能也能做到随CPU个数的增多而线性扩展。

需要注意的是，所有原子操作方法的被操作数形参必须是指针类型，通过指针变量可以获取被操作数在内存中的地址，从而施加特殊的CPU指令，确保同一时间只有一个goroutine能够进行操作。

再强调一遍，原子操作由底层硬件支持，而锁则由操作系统的调度器实现。锁应当用来保护一段逻辑，对于一个变量更新的保护，原子操作通常会更有效率，并且更能利用计算机多核的优势，如果要更新的是一个复合对象，则应当使用atomic.Value
封装好的实现。