Go 原子操作

40次阅读

共计 2420 个字符,预计需要花费 7 分钟才能阅读完成。

概念
原子操作,意思就是执行的过程不能背终端的操作。在针对某个值的原子操作执行过程中,cpu 不会再去执行其他针对这个值得操作。在底层,这会由 CPU 提供芯片级别的支持,所以绝对有效。即使在拥有多 CPU 核心,或者多 CPU 的计算机系统中,原子操作的保证也是不可撼动的。Go 语言提供了院子操作的包 atomic。其中有很多函数可以帮助我们进行原子操作。但是只能对几种简单类型进行原子操作:int32、int64、uint32、uint64、uintptr 和 unsafe.Ponter。atomic 为这些简单类型童工了 5 中操作函数:增或减、比较并交换、载入、存储和交换。
为什么选择原子操作
我们知道 go 语言在 sync 包中提供了锁的包,但是为什么我们还要使用 atomic 原子操作呢?总结下来有一下几个原因:

加锁的代价比较耗时,需要上下文切换。即使是在 go 语言的 goroutine 中也需要上下文的切换
只是针对基本类型,可以使用原子操作保证线程安全
原子操作在用户态可以完成,性能比互斥锁要高
针对特定需求,原子操作的步骤简单,不需要加锁 - 操作 - 解锁 这样的步骤

五种操作
一下 5 中操作例子都是用 uint64 来写
增或减
针对以上 6 种简单类型,atomic 包支持院子增 / 减的操作函数。
var i64 uint64
// 第一个参数必须是指针
atomic.AddUint64(&i64,5)
// 在 uint 类型中可以使用 ^uint64(0) 的方式打到减的效果
atomic.AddUint64(&i64, ^uint64(0))
fmt.Println(i64)
比较并交换(CAS-Compare And Swap)
var i64 uint64
i64 = 5
// cas 接受 3 个参数,第一个为需要替换值得指针,第二个为旧值,第三个为新值
// 当指针指向的值,跟你传递的旧值相等的情况下 指针指向的值会被替换
ok := atomic.CompareAndSwapUint64(&i64,5, 50)
fmt.Println(ok)
// 当指针指向的值跟传递的旧值不相等,则返回 false
ok = atomic.CompareAndSwapUint64(&i64,40, 50)
fmt.Println(ok)
载入
var i64 uint64
i64 = 1
//load 函数接收一个指针类型 返回指针指向的值
num := atomic.LoadUint64(&i64)
fmt.Println(num)
存储
var i64 uint64
i64 = 1
//store 函数接受一个指针类型和一个值 函数将会把值赋到指针地址中
atomic.StoreUint64(&i64, 5)
fmt.Println(i64)
交换
var i64 uint64
i64 = 1
//swap 接受一个指针 一个值。函数会把值赋给指针 并返回旧值
old := atomic.SwapUint64(&i64, 5)
fmt.Println(“old:”,old,”new:”,i64)
原子值
原子值可接受的备操作值得类型不限,这意味着我们可以把任何类型的值放入原子值。原子值只有 2 个公开的方法:Load、Store。一个是获取另一个是存储。下面来看下简单操作:
var countVal atomic.Value
//store 函数 接受 interface 并存储
countVal.Store([]int{1,2,3,4,5})
//load 函数 返回 atomic.value 中的值
list := countVal.Load().([]int)

fmt.Println(list)
下面有一个并发安全的 int 数组的例子
package main

import (
“errors”
“sync/atomic”
)

func main() {

}

// ConcurrentArray 代表并发安全的整数数组接口。
type ConcurrentArray interface {
// Set 用于设置指定索引上的元素值。
Set(index uint32, elem int) (err error)
// Get 用于获取指定索引上的元素值。
Get(index uint32) (elem int, err error)
// Len 用于获取数组的长度。
Len() uint32
}

type MyArray struct {
val atomic.Value
length uint32
}

func (array *MyArray)CheckValue()(err error){
if array.val.Load() == nil{
errors.New(“array is empty”)
}
return nil
}

func (array *MyArray)CheckIndex(index uint32)(error){
if array.length <= index{
errors.New(“array out of the range”)
}

return nil
}

func (m *MyArray)Set(index uint32, elem int)(err error){
if err := m.CheckValue();err != nil{
return err
}

if err = m.CheckIndex(index);err!=nil{
return err
}

newArray := make([]int, m.length)
copy(newArray ,m.val.Load().([]int))
newArray[index] = elem
m.val.Store(newArray)

return nil
}

func (array *MyArray)Get(index uint32) (elem int, err error){
if err := array.CheckValue();err != nil{
return 0,err
}

if err = array.CheckIndex(index);err!=nil{
return 0,err
}

num := array.val.Load().([]int)[index]

return num, err
}

正文完
 0