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

程序员文章站 2022-06-24 10:13:44

目录go 语言提供了哪些原子操作atomic.value保证任意值的读写安全本文我们详细聊一下go语言的原子操作的用法，啥是原子操作呢？顾名思义，原子操作就是具备原子性的操作... 是不是感觉说了跟没...

cpu执行一系列操作时不可能不发生中断，但如果我们在执行多个操作时，能让他们的中间状态对外不可见，那我们就可以宣称他们拥有了"不可分割”的原子性。
类似的解释我们在数据库事务的acid概念里也听过，只不过这里保障原子性的执行体是cpu。

go 语言提供了哪些原子操作

go语言通过内置包sync/atomic提供了对原子操作的支持，其提供的原子操作有以下几大类：

增减，操作方法的命名方式为addxxxtype，保证对操作数进行原子的增减，支持的类型为int32、int64、uint32、uint64、uintptr，使用时以实际类型替换前面我说的xxxtype就是对应的操作方法。
载入，保证了读取到操作数前没有其他任务对它进行变更，操作方法的命名方式为loadxxxtype，支持的类型除了基础类型外还支持pointer，也就是支持载入任何类型的指针。
存储，有载入了就必然有存储操作，这类操作的方法名以store开头，支持的类型跟载入操作支持的那些一样。
比较并交换，也就是cas （compare and swap），像go的很多并发原语实现就是依赖的cas操作，同样是支持上面列的那些类型。
交换，这个简单粗暴一些，不比较直接交换，这个操作很少会用。

互斥锁跟原子操作的区别

平日里，在并发编程里，go语言sync包里的同步原语mutex是我们经常用来保证并发安全的，那么他跟atomic包里的这些操作有啥区别呢？在我看来他们在使用目的和底层实现上都不一样：

使用目的：互斥锁是用来保护一段逻辑，原子操作用于对一个变量的更新保护。
底层实现：mutex由操作系统的调度器实现，而atomic包中的原子操作则由底层硬件指令直接提供支持，这些指令在执行的过程中是不允许中断的，因此原子操作可以在lock-free的情况下保证并发安全，并且它的性能也能做到随cpu个数的增多而线性扩展。

对于一个变量更新的保护，原子操作通常会更有效率，并且更能利用计算机多核的优势。

比如下面这个，使用互斥锁的并发计数器程序：

func mutexadd() {
 var a int32 =  0
 var wg sync.waitgroup
 var mu sync.mutex
 start := time.now()
 for i := 0; i < 100000000; i++ {
  wg.add(1)
  go func() {
   defer wg.done()
   mu.lock()
   a += 1
   mu.unlock()
  }()
 }
 wg.wait()
 timespends := time.now().sub(start).nanoseconds()
 fmt.printf("use mutex a is %d, spend time: %v\n", a, timespends)
}

把mutex改成用方法atomic.addint32(&a, 1)调用，在不加锁的情况下仍然能确保对变量递增的并发安全。

func atomicadd() {
 var a int32 =  0
 var wg sync.waitgroup
 start := time.now()
 for i := 0; i < 1000000; i++ {
  wg.add(1)
  go func() {
   defer wg.done()
   atomic.addint32(&a, 1)
  }()
 }
 wg.wait()
 timespends := time.now().sub(start).nanoseconds()
 fmt.printf("use atomic a is %d, spend time: %v\n", atomic.loadint32(&a), timespends)
}

可以在本地运行以上这两段代码，可以观察到计数器的结果都最后都是1000000，都是线程安全的。
需要注意的是，所有原子操作方法的被操作数形参必须是指针类型，通过指针变量可以获取被操作数在内存中的地址，从而施加特殊的cpu指令，确保同一时间只有一个goroutine能够进行操作。
上面的例子除了增加操作外我们还演示了载入操作，接下来我们来看一下cas操作。

比较并交换

该操作简称cas (compare and swap)。这类操作的前缀为 compareandswap :

func compareandswapint32(addr *int32, old, new int32) (swapped bool)

func compareandswappointer(addr *unsafe.pointer, old, new unsafe.pointer) (swapped bool)

该操作在进行交换前首先确保被操作数的值未被更改，即仍然保存着参数 old 所记录的值，满足此前提条件下才进行交换操作。cas的做法类似操作数据库时常见的乐观锁机制。

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

上面我只列出了比较典型的int32和unsafe.pointer类型的cas方法，主要是想说除了读数值类型进行比较交换，还支持对指针进行比较交换。

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

// 定义一个struct类型p
type p struct{ x, y, z int }
  
// 执行类型p的指针
var pp *p
  
func main() {
  
    // 定义一个执行unsafe.pointer值的指针变量
    var unsafe1 = (*unsafe.pointer)(unsafe.pointer(&pp))
  
    // old pointer
    var sy p
  
    // 为了演示效果先将unsafe1设置成old pointer
    px := atomic.swappointer(
        unsafe1, unsafe.pointer(&sy))
  
    // 执行cas操作，交换成功，结果返回true
    y := atomic.compareandswappointer(
        unsafe1, unsafe.pointer(&sy), px)
  
    fmt.println(y)
}

上面的示例并不是在并发环境下进行的cas，只是为了演示效果，先把被操作数设置成了old pointer。
其实mutex的底层实现也是依赖原子操作中的cas实现的，原子操作的atomic包相当于是sync包里的那些同步原语的实现依赖。

比如互斥锁mutex的结构里有一个state字段，其是表示锁状态的状态位。

type mutex struct {
 state int32
 sema  uint32
}

为了方便理解，我们在这里将它的状态定义为0和1，0代表目前该锁空闲，1代表已被加锁，以下是sync.mutex中lock方法的部分实现代码。

func (m *mutex) lock() {
   // fast path: grab unlocked mutex.
   if atomic.compareandswapint32(&m.state, 0, mutexlocked) {
       if race.enabled {
           race.acquire(unsafe.pointer(m))
       }
       return
   }
   // slow path (outlined so that the fast path can be inlined)
    m.lockslow()
}

在atomic.compareandswapint32(&m.state, 0, mutexlocked)中，m.state代表锁的状态，通过cas方法，判断锁此时的状态是否空闲（m.state==0），是，则对其加锁（mutexlocked常量的值为1）。

atomic.value保证任意值的读写安全

atomic包里提供了一套store开头的方法，用来保证各种类型变量的并发写安全，避免其他操作读到了修改变量过程中的脏数据。

func storeint32(addr *int32, val int32)

func storeint64(addr *int64, val int64)

func storepointer(addr *unsafe.pointer, val unsafe.pointer)

 
...

这些操作方法的定义与上面介绍的那些操作的方法类似，我就不再演示怎么使用这些方法了。

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

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

atomic.value类型对外暴露了两个方法：

v.store(c) - 写操作，将原始的变量c存放到一个atomic.value类型的v里。
c := v.load() - 读操作，从线程安全的v中读取上一步存放的内容。

1.17 版本我看还增加了swap和compareandswap方法。

简洁的接口使得它的使用也很简单，只需将需要做并发保护的变量读取和赋值操作用load()和store()代替就行了。
由于load()返回的是一个interface{}类型，所以在使用前我们记得要先转换成具体类型的值，再使用。下面是一个简单的

例子演示atomic.value的用法。

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

你也可以试试，不用atomic.value，直接给rectange类型的指针变量赋值，看看在并发条件下，两个字段的值是不是能跟预期的一样变成10和15。

总结

本文详细介绍了go语言原子操作atomic包中会被高频使用的操作的使用场景和用法，当然我并没有罗列atomic包里所有操作的用法，主要是考虑到有的用到的地方实在不多，或者是已经被更好的方式替代，还有就是觉得确实没必要，看完本文的内容相信你已经完全具备自行探索atomic包的能力了。

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

到此这篇关于详解golang五种原子性操作的用法的文章就介绍到这了,更多相关详解golang五种原子性操作的用法内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！