GoLang 原子操作详细教程 - 探索Go语言并发编程

概述

atomic 提供的原子操作能够确保任一时刻只能有一个goroutine对变量进行操作，善用 atomic 能够避免程序中出现大量的锁操作，应该是方法内部实现了锁操作。atomic常见操作有：

1. 载入
2. 比较并交换
3. 交换
4. 存储
5. 增减

增减

atomic 包中提供了如下以Add为前缀的增减操作，对变量进行增加或者减少:

1. func AddInt32(addr *int32, delta int32) (new int32)
2. func AddInt64(addr *int64, delta int64) (new int64)
3. func AddUint32(addr *uint32, delta uint32) (new uint32)
4. func AddUint64(addr *uint64, delta uint64) (new uint64)
5. func AddUintptr(addr *uintptr, delta uintptr) (new uintptr)

需要注意的是，第一个参数必须是指针类型的值，通过指针变量可以获取被操作数在内存中的地址，确保同一时间只有一个goroutine能够进行操作。先来看一个例子： 分别用“锁”和原子操作来实现多个 goroutine 对同一个变量进行累加操作。

使用锁实现，可以保证每一个时刻保证只有一个协程可以拿到变量，并且对变量进行写的操作：

func main() {
 var (
       mux   sync.Mutex
        total = 0
   )

   for i := 0; i < 10; i++ {
       go func() {
         for {
               mux.Lock()
              total += 1
              mux.Unlock()
                time.Sleep(time.Millisecond)
            }
       }()
 }

   time.Sleep(time.Second) // 保证所有的协程都执行完毕
 fmt.Println("The total number is", total)
}

由于一直使用锁定的操作会很麻烦，所以我们可以使用 atomic 实现，也是没有问题的：

func main() {
    var total int64

 for i := 0; i < 10; i++ {
       go func() {
         for {
               atomic.AddInt64(&total, 1) // 应该类似事务，内部会对变量加锁
               time.Sleep(time.Millisecond)
            }
       }()
 }

   time.Sleep(time.Second)
 fmt.Println("The total number is", total)
}

载入

atomic 包中提供了如下以Load为前缀的载入操作，应该就是读的时候加读锁:

1. func LoadInt32(addr *int32) (val int32)
2. func LoadInt64(addr *int64) (val int64)
3. func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)
4. func LoadUint32(addr *uint32) (val uint32)
5. func LoadUint64(addr *uint64) (val uint64)
6. func LoadUintptr(addr *uintptr) (val uintptr)

载入操作能够保证原子的读变量的值，当读取的时候，任何其他 goroutine 都无法对该变量进行读写.

比较交换

该操作简称 CAS(Compare And Swap)。 这类操作的前缀为 CompareAndSwap ，比较新的值和旧的值是否相等，相等的话就交换，返回布尔值:

1. func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)
2. func CompareAndSwapInt64(addr *int64, old, new int64) (swapped bool)
3. func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)
4. func CompareAndSwapUint32(addr *uint32, old, new uint32) (swapped bool)
5. func CompareAndSwapUint64(addr *uint64, old, new uint64) (swapped bool)
6. func CompareAndSwapUintptr(addr *uintptr, old, new uintptr) (swapped bool)

该操作在进行交换前首先确保变量的值未被更改，即仍然保持参数 old 所记录的值，满足此前提下才进行交换操作。CAS的做法类似操作数据库时常见的乐观锁机制。 需要注意的是，当有大量的goroutine 对变量进行读写操作时，可能导致CAS操作无法成功，这时可以利用for循环多次尝试。

var value int64

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

func main() {
 value = 10
  atomicAddOp(1)
  fmt.Println(value) // 输出11
}

交换

此类操作直接交换，并且返回旧的值，的前缀为 Swap：

1. func SwapInt32(addr *int32, new int32) (old int32)
2. func SwapInt64(addr *int64, new int64) (old int64)
3. func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)
4. func SwapUint32(addr *uint32, new uint32) (old uint32)
5. func SwapUint64(addr *uint64, new uint64) (old uint64)
6. func SwapUintptr(addr *uintptr, new uintptr) (old uintptr)

相对于CAS，明显此类操作更为暴力直接，并不管变量的旧值是否被改变，直接赋予新值然后返回背替换的值。

func main() {
   var oldValue int32
  oldValue = 10
   fmt.Println(atomic.SwapInt32(&oldValue, 20), oldValue) // 10 20
}

存储

此类操作的前缀为 Store，这个操作没有任何的返回值，类似给变量写操作：

1. func StoreInt32(addr *int32, val int32)
2. func StoreInt64(addr *int64, val int64)
3. func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer)
4. func StoreUint32(addr *uint32, val uint32)
5. func StoreUint64(addr *uint64, val uint64)
6. func StoreUintptr(addr *uintptr, val uintptr)

在原子地存储某个值的过程中，任何 goroutine 都不会进行针对同一个值的读或写操作。

func main() {
    var oldValue int32
  oldValue = 10
   atomic.StoreInt32(&oldValue, 20)
    fmt.Println(oldValue) // 20
}