Go语言 原子操作

原子操作就是不可中断的操作,外界是看不到原子操作的中间状态,要么看到原子操作已经完成,要么看到原子操作已经结束。在某个值的原子操作执行的过程中,CPU绝对不会再去执行其他针对该值的操作,那么其他操作也是原子操作。

Go语言中提供的原子操作都是非侵入式的,在标准库代码包sync/atomic中提供了相关的原子函数。

增或减
用于增或减的原子操作的函数名称都是以”Add”开头的,后面跟具体的类型名,比如下面这个示例就是int64类型的原子减操作

func main() {
   var  counter int64 =  23
   atomic.AddInt64(&counter,-3)
   fmt.Println(counter)
}
---output---
20

原子函数的第一个参数都是指向变量类型的指针,是因为原子操作需要知道该变量在内存中的存放位置,然后加以特殊的CPU指令,也就是说对于不能取得内存存放地址的变量是无法进行原子操作的。第二个参数的类型会自动转换为与第一个参数相同的类型。此外,原子操作会自动将操作后的值赋值给变量,无需我们自己手动赋值了。

对于 atomic.AddUint32() 和 atomic.AddUint64() 的第二个参数为 uint32 与 uint64,因此无法直接传递一个负的数值进行减法操作,Go语言提供了另一种方法来迂回实现:使用二进制补码的特性

注意:unsafe.Pointer 类型的值无法被加减。

比较并交换(Compare And Swap)
简称CAS,在标准库代码包sync/atomic中以”Compare And Swap“为前缀的若干函数就是CAS操作函数,比如下面这个

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

第一个参数的值是这个变量的指针,第二个参数是这个变量的旧值,第三个参数指的是这个变量的新值。

运行过程:调用CompareAndSwapInt32 后,会先判断这个指针上的值是否跟旧值相等,若相等,就用新值覆盖掉这个值,若相等,那么后面的操作就会被忽略掉。返回一个 swapped 布尔值,表示是否已经进行了值替换操作。

与锁有不同之处:锁总是假设会有并发操作修改被操作的值,而CAS总是假设值没有被修改,因此CAS比起锁要更低的性能损耗,锁被称为悲观锁,而CAS被称为乐观锁。

CAS的使用示例

var value int32
func AddValue(delta int32)  {
   for {
      v:= value
      if atomic.CompareAndSwapInt32(&value,v,(v+delta)) {
         break
      }
   }
}

由示例可以看出,我们需要多次使用for循环来判断该值是否已被更改,为了保证CAS操作成功,仅在 CompareAndSwapInt32 返回为 true时才退出循环,这跟自旋锁的自旋行为相似。

载入与存储
对一个值进行读或写时,并不代表这个值是最新的值,也有可能是在在读或写的过程中进行了并发的写操作导致原值改变。为了解决这问题,Go语言的标准库代码包sync/atomic提供了原子的读取(Load为前缀的函数)或写入(Store为前缀的函数)某个值

将上面的示例改为原子读取

var value int32
func AddValue(delta int32)  {
   for {
      v:= atomic.LoadInt32(&value)
      if atomic.CompareAndSwapInt32(&value,v,(v+delta)) {
         break
      }
   }
}

原子写入总会成功,因为它不需要关心原值是什么,而CAS中必须关注旧值,因此原子写入并不能代替CAS,原子写入包含两个参数,以下面的StroeInt32为例:

//第一个参数是被操作值的指针,第二个是被操作值的新值
func StoreInt32(addr *int32, val int32) 

交换
这类操作都以”Swap“开头的函数,称为”原子交换操作“,功能与之前说的CAS操作与原子写入操作有相似之处。

func SwapInt32(addr *int32, new int32) (old int32)

以 SwapInt32 为例,第一个参数是int32类型的指针,第二个是新值。原子交换操作不需要关心原值,而是直接设置新值,但是会返回被操作值的旧值。

原子值
Go语言的标准库代码包sync/atomic中有一个叫做Value的原子值,它是一个结构体类型,用于存储需要原子读写的值,结构体如下

// Value提供原子加载并存储一致类型的值。
// Value的零值从Load返回nil。
//调用Store后,不得复制值。
//首次使用后不得复制值。
type Value struct {
   v interface{}
}

可以看出结构体内是一个 v interface{},也就是说 该Value原子值可以保存任何类型的需要原子读写的值。

使用方式如下:

var Atomicvalue  atomic.Value

该类型有两个公开的指针方法

//原子的读取原子值实例中存储的值,返回一个 interface{} 类型的值,且不接受任何参数。
//若未曾通过store方法存储值之前,会返回nil
func (v *Value) Load() (x interface{})

//原子的在原子实例中存储一个值,接收一个 interface{} 类型(不能为nil)的参数,且不会返回任何值
func (v *Value) Store(x interface{})

一旦原子值实例存储了某个类型的值,那么之后Store存储的值就必须是与该类型一致,否则就会引发panic。

严格来讲,atomic.Value类型的变量一旦被声明,就不应该被复制到其他地方。比如:作为源值赋值给其他变量,作为参数传递给函数,作为结果值从函数返回,作为元素值通过通道传递,这些都会造成值的复制。

但是atomic.Value类型的指针类型变量就不会存在这个问题,原因是对结构体的复制不但会生成该值的副本,还会生成其中字段的副本,这样那么并发引发的值变化都与原值没关系了。

看下面这个小示例

func main() {
   var Atomicvalue  atomic.Value
   Atomicvalue.Store([]int{1,2,3,4,5})
   anotherStore(Atomicvalue)
   fmt.Println("main: ",Atomicvalue)
}

func anotherStore(Atomicvalue atomic.Value)  {
   Atomicvalue.Store([]int{6,7,8,9,10})
   fmt.Println("anotherStore: ",Atomicvalue)
}
---output---
anotherStore:  {[6 7 8 9 10]}
main:  {[1 2 3 4 5]}
    原文作者:小杰的快乐时光
    原文地址: https://www.jianshu.com/p/a0be632df99b
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞