Golang同步:原子操作使用

前端之家收集整理的这篇文章主要介绍了Golang同步:原子操作使用前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

原子操作即是进行过程中不能被中断的操作。针对某个值的原子操作在被进行的过程中,cpu绝不会再去进行其他的针对该值的操作。
为了实现这样的严谨性,原子操作仅会由一个独立的cpu指令代表和完成。

  • GO语言提供的原子操作都是非入侵式的,由标准库sync/atomic中的众多函数代表
  • 类型包括int32,int64,uint32,uint64,uintptr,unsafe.Pointer,共六个。
  • 这些函数提供的原子操作共有五种:增或减,比较并交换,载入,存储和交换

int各种类型取值范围

类型 长度(字节) 值范围
int8 1 -128 ~ 127
uint8(byte) 1 0 ~ 255
int16 2 32768~32767
uint16 2 0~65535
int32 4 2147483648~2147483647
uint32 4 0~4294967295
int64 8 -9223372036854775808~9223372036854775807
uint64 8 0~18446744073709551615
int 平台相关 平台相关
uint 平台相关 平台相关
uintptr 同指针 在32位平 下为4字节,64位平 下为8字节

增或减Add

函数名称都以Add为前缀,并后跟针对的具体类型的名称

  • 被操作的类型只能是数值类型
  • int32,uintptr类型可以使用原子增或减操作
  • 第一个参数值必须是一个指针类型的值,以便施加特殊的cpu指令
  • 第二个参数值的类型和第一个被操作值的类型总是相同的。

示例

package main

import (
    "fmt"
    "sync/atomic"
)

func main(){
    var i32 int32
    fmt.Println("=====old i32 value=====")
    fmt.Println(i32)
    //第一个参数值必须是一个指针类型的值,因为该函数需要获得被操作值在内存中的存放位置,以便施加特殊的cpu指令
    //结束时会返回原子操作后的新值
    newI32 := atomic.AddInt32(&i32,3)
    fmt.Println("=====new i32 value=====")
    fmt.Println(i32)
    fmt.Println(newI32)

    var i64 int64
    fmt.Println("=====old i64 value=====")
    fmt.Println(i64)
    newI64 := atomic.AddInt64(&i64,-3)
    fmt.Println("=====new i64 value=====")
    fmt.Println(i64)
    fmt.Println(newI64)

}

结果:
/usr/local/go/bin/go run /Users/liuxinming/go/src/free/learngo/atomic/add/add.go
=====old i32 value=====
0
=====new i32 value=====
-3
-3
=====old i64 value=====
0
=====new i64 value=====
-3
-3

比较并交换CAS

Compare And Swap 简称CAS,在sync/atomic包种,这类原子操作由名称以‘CompareAndSwap’为前缀的若干个函数代表。

  • 声明如下
func CompareAndSwapInt32(addr *int32,old,new int32) (swapped bool)
  • 调用函数后,会先判断参数addr指向的被操作值与参数old的值是否相等
  • 仅当此判断得到肯定的结果之后,才会用参数new代表的新值替换掉原先的旧值,否则操作就会被忽略。
  • so,需要用for循环不断进行尝试,直到成功为止

  • 使用锁的做法趋于悲观

    • 我们总假设会有并发的操作要修改被操作的值,并使用锁将相关操作放入临界区中加以保护
  • 使用CAS操作的做法趋于乐观
    • 总是假设被操作值未曾被改变(即与旧值相等),并一旦确认这个假设的真实性就立即进行值替换。

示例

package main

import (
    "fmt"
    "sync/atomic"
)

var value int32

func main()  {
    fmt.Println("======old value=======")
    fmt.Println(value)
    fmt.Println("======CAS value=======")
    addValue(3)
    fmt.Println(value)


}

//不断地尝试原子地更新value的值,直到操作成功为止
func addValue(delta int32){
    //在被操作值被频繁变更的情况下,CAS操作并不那么容易成功
    //so 不得不利用for循环以进行多次尝试
    for {
        v := value
        if atomic.CompareAndSwapInt32(&value,v,(v + delta)){
            //在函数的结果值为true时,退出循环
            break
        }
        //操作失败的缘由总会是value的旧值已不与v的值相等了.
        //CAS操作虽然不会让某个Goroutine阻塞在某条语句上,但是仍可能会使流产的执行暂时停一下,不过时间大都极其短暂.
    }
}

结果:
======old value=======
0
======CAS value=======
3

载入Load

上面的比较并交换案例总 v:= value为变量v赋值,但… 要注意,在进行读取value的操作的过程中,其他对此值的读写操作是可以被同时进行的,那么这个读操作很可能会读取到一个只被修改了一半的数据.

  • so so so,我们要使用sync/atomic代码包同样为我们提供了一系列的函数,以Load为前缀(载入),来确保这样的糟糕事情发生。

示例

package main

import (
    "fmt"
    "sync/atomic"
)

var value int32

func main()  {
    fmt.Println("======old value=======")
    fmt.Println(value)
    fmt.Println("======CAS value=======")
    addValue(3)
    fmt.Println(value)


}

//不断地尝试原子地更新value的值,CAS操作并不那么容易成功
    //so 不得不利用for循环以进行多次尝试
    for {
        //v := value
        //在进行读取value的操作的过程中,那么这个读操作很可能会读取到一个只被修改了一半的数据.
        //因此我们要使用载入
        v := atomic.LoadInt32(&value)
        if atomic.CompareAndSwapInt32(&value,不过时间大都极其短暂.
    }
}
  • atomic.LoadInt32接受一个*int32类型的指针值
  • 返回该指针指向的那个值

存储Store

与读取操作相对应的是写入操作。 而sync/atomic包也提供了与原子的载入函数相对应的原子的值存储函数。 以Store为前缀

  • 在原子地存储某个值的过程中,任何cpu都不会进行针对同一个值的读或写操作。
  • 原子的值存储操作总会成功,因为它并不会关心被操作值的旧值是什么
  • 和CAS操作有着明显的区别
fmt.Println("======Store value=======")
    atomic.StoreInt32(&value, 10)
    fmt.Println(value)

交换Swap

  • 与CAS操作不同,原子交换操作不会关心被操作的旧值。
  • 它会直接设置新值
  • 它会返回被操作值的旧值
  • 此类操作比CAS操作的约束更少,同时又比原子载入操作的功能更强

实际案例(继续改造上一版代码)

//数据文件的实现类型
type myDataFile struct {
    f *os.File  //文件
    fmutex sync.RWMutex //被用于文件的读写锁
    rcond   *sync.Cond   //读操作需要用到的条件变量
    woffset int64 // 写操作需要用到的偏移量
    roffset int64 // 读操作需要用到的偏移量
    dataLen uint32 //数据块长度
}

//此处省略...
func (df *myDataFile) Read() (rsn int64,d Data,err error){
    // 读取并更新读偏移量
    var offset int64
    for {
        offset = atomic.LoadInt64(&df.roffset)
        if atomic.CompareAndSwapInt64(&df.roffset,offset,(offset + int64(df.dataLen))){
            break
        }
    }

    //读取一个数据块,最后读取的数据块序列号
    rsn = offset / int64(df.dataLen)
    bytes := make([]byte,df.dataLen)
    //读写锁:读锁定
    df.fmutex.RLock()
    defer df.fmutex.RUnlock()

    for {
        _,err = df.f.ReadAt(bytes,offset)
        if err != nil {
            if err == io.EOF {
                //暂时放弃fmutex的 读锁,并等待通知的到来
                df.rcond.Wait()
                continue
            }
        }
        break
    }
    d = bytes
    return
}
func (df *myDataFile) Write(d Data) (wsn int64,err error){
    //读取并更新写的偏移量
    var offset int64
    for {
        offset = atomic.LoadInt64(&df.woffset)
        if atomic.CompareAndSwapInt64(&df.woffset,(offset + int64(df.dataLen))){
            break
        }
    }


    //写入一个数据块,最后写入数据块的序号
    wsn = offset / int64(df.dataLen)
    var bytes []byte
    if len(d) > int(df.dataLen){
        bytes = d[0:df.dataLen]
    }else{
        bytes = d
    }
    df.fmutex.Lock()
    defer df.fmutex.Unlock()
    _,err = df.f.Write(bytes)
    //发送通知
    df.rcond.Signal()
    return
}
func (df *myDataFile) Rsn() int64{
    offset := atomic.LoadInt64(&df.roffset)
    return offset / int64(df.dataLen)
}

func (df *myDataFile) Wsn() int64{
    offset := atomic.LoadInt64(&df.woffset)
    return offset / int64(df.dataLen)
}

完整代码放在GITHUB:
https://github.com/lxmgo/learngo

一些学习过程整理,希望对大家学习Go语言有所帮助。

猜你在找的Go相关文章