Go语言学习笔记—golang并发编程之原子操作

文章目录

  • 一 原子变量的引入
  • 二 原子操作详解
    • 2.1 增减
    • 2.2 比较并交换
    • 2.3 载入
    • 2.4 交换
    • 2.5 存储


一 原子变量的引入

先看一个实例:

package main 
 
import ( 
    "fmt" 
    "sync" 
    "time" 
) 
 
var i = 100 
 
func add() { 
    i++ 
} 
 
func sub() { 
    i-- 
} 
 
func main() { 
    for i := 0; i < 100; i++ { 
        go add() 
        go sub() 
    } 
 
    time.Sleep(time.Second * 3) 
    fmt.Printf("i: %v\n", i) 
 
} 
 

运行结果:

i: 99

由于资源竞争的原因,当某一个goroutine在访问某个数据资源的时候,按照数值,已经判断好了条件,然后又被其他的goroutine抢占了资源,并修改了数值,等这个goroutine再继续访问这个数据的时候,数值已经不对了。

此时可以使用锁实现协程的同步:

package main 
 
import ( 
    "fmt" 
    "sync" 
    "time" 
) 
 
var i = 100 
var lock sync.Mutex 
 
func add() { 
    lock.Lock() 
    i++ 
    lock.Unlock() 
} 
 
func sub() { 
    lock.Lock() 
    i-- 
    lock.Unlock() 
} 
 
func main() { 
    for i := 0; i < 100; i++ { 
        go add() 
        go sub() 
    } 
 
    time.Sleep(time.Second * 3) 
    fmt.Printf("i: %v\n", i) 
 
} 

运行结果:

i: 100  

当我们想要对某个变量并发安全的修改,除了使用官方提供的 mutex,还可以使用 sync/atomic 包的原子操作,它能够保证对变量的读取或修改期间不被其他的协程所影响。atomic提供的原子操作能够确保任一时刻只有一个goroutine对变量进行操作,善用atomic能够避免程序中出现大量的锁操作。

下面使用原子操作:

package main 
 
import ( 
    "fmt" 
    "sync/atomic" 
    "time" 
) 
 
var i int32 = 100 
 
func add() { 
    atomic.AddInt32(&i, 1) 
} 
 
func sub() { 
    atomic.AddInt32(&i, -1) 
} 
 
func main() { 
    for i := 0; i < 100; i++ { 
        go add() 
        go sub() 
    } 
 
    time.Sleep(time.Second * 3) 
    fmt.Printf("i: %v\n", i) 
 
} 

运行结果:

i: 100 

二 原子操作详解

常见操作:

  1. 增减Add
  2. 载入Load
  3. 比较并交换CompareAndSwap
  4. 交换Swap
  5. 存储Store

注意:atomic 操作的对象是一个地址,你需要把可寻址的变量的地址作为参数传递给方法,而不是把变量的值传递给方法

2.1 增减

atomic包中提供了如下以Add为前缀的增减操作:

- func AddInt32(addr *int32, delta int32) (new int32)
- func AddInt64(addr *int64, delta int64) (new int64)
- func AddUint32(addr *unit32, delta uint32) (new uint32)
- func AddUint64(addr *uint64, delta uint64) (new uint64)
- func AddUintptr(addr *uintptr, delta uintptr) (new uintptr)
  • 被操作的类型只能是数值类型
  • int32,int64,uint32,uint64,uintptr类型可以使用原子增或减操作
  • 第一个参数值必须是一个指针类型的值,以便施加特殊的CPU指令
  • 第二个参数值的类型和第一个被操作值的类型总是相同的。

在第一节最后已实例演示,此处不再赘述。

2.2 比较并交换

该操作简称CAS(Compare And Swap)。这类操作的前缀为CompareAndSwap:

- func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)
- func CompareAndSwapInt64(addr *int64, old, new int64) (swapped bool)
- func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)
- func CompareAndSwapUint32(addr *uint32, old, new uint32) (swapped bool)
- func CompareAndSwapUint64(addr *uint64, old, new uint64) (swapped bool)
- func CompareAndSwapUintptr(addr *uintptr, old, new uintptr) (swapped bool)

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

  • 调用函数后,会先判断参数addr指向的被操作值与参数old的值是否相等

  • 仅当此判断得到肯定的结果之后,才会用参数new代表的新值替换掉原先的旧值,否则操作就会被忽略

  • 需要用for循环不断进行尝试,直到成功为止

实例演示:

package main

import (
	"fmt"
	"sync/atomic"
)

var value int32

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

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

}

运行结果:

[Running] go run "c:\Users\Mechrevo\Desktop\go_pro\test.go"
----------old value----------
0
----------CAS value----------
3

[Done] exited with code=0 in 1.234 seconds

2.3 载入

atomic包中提供了如下以Load为前缀的载入操作:

- func LoadInt32(addr *int32) (val int32)
- func LoadInt64(addr *int64) (val int64)
- func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)
- func LoadUint32(addr *uint32) (val uint32)
- func LoadUint64(addr *uint64) (val uint64)
- func LoadUintptr(addr *uintptr) (val uintptr)

载入操作能够保证原子的读变量的值,当读取的时候,任何其他CPU操作都无法对该变量进行读写,其实现机制受到底层硬件的支持。

在2.2中实例中 v:= value为变量v赋值,但… 要注意,在进行读取value的操作的过程中,其他对此值的读写操作是可以被同时进行的,那么这个读操作很可能会读取到一个只被修改了一半的数据。因此我们要使用sync/atomic代码包同样为我们提供了一系列的函数,以Load为前缀(载入),来确保这样的糟糕事情发生。

实例演示:

package main

import (
	"fmt"
	"sync/atomic"
)

var value int32

func addValue(delta int32) {
	for {
		//v := value
		//在进行读取value的操作的过程中,其他对此值的读写操作是可以被同时进行的,那么这个读操作很可能会读取到一个只被修改了一半的数据.
		//因此我们要使用载入
		v := atomic.LoadInt32(&value)
		if atomic.CompareAndSwapInt32(&value, v, (v + delta)) {
			break
		}
	}
}

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

}

运行结果:

[Running] go run "c:\Users\Mechrevo\Desktop\go_pro\tempCodeRunnerFile.go"
----------old value----------
0
----------CAS value----------
3

[Done] exited with code=0 in 1.309 seconds

2.4 交换

此类操作的前缀为Swap:

- func SwapInt32(addr *int32, new int32) (old int32)
- func SwapInt64(addr *int64, new int64) (old int64)
- func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)
- func SwapUint32(addr *uint32, new uint32) (old uint32)
- func SwapUint64(addr *uint64, new uint64) (old uint64)
- func SwapUintptr(addr *uintptr, new uintptr) (old uintptr)
  • 与CAS操作不同,原子交换操作不会关心被操作的旧值。
  • 它会直接设置新值
  • 它会返回被操作值的旧值
  • 此类操作比CAS操作的约束更少,同时又比原子载入操作的功能更强

实例演示:

package main

import (
	"fmt"
	"sync/atomic"
)

func main() {
	var j int32 = 1
	var k int32 = 2
	j_old := atomic.SwapInt32(&j, k)
	fmt.Println("old,new:", j_old, j)

}

运行结果:

[Running] go run "c:\Users\Mechrevo\Desktop\go_pro\test.go"
old,new: 1 2

[Done] exited with code=0 in 1.187 seconds

2.5 存储

此类操作的前缀为Store:

- func StoreInt32(addr *int32, val int32)
- func StoreInt64(addr *int64, val int64)
- func StorePointer(addr *unsafe.Pointer, val unsafae.Pointer)
- func StoreUint32(addr *uint32, val uint32)
- func StoreUint64(addr *uint64, val uint64)
- func StoreUintptr(addr *uintptr, val uintptr)

此类操作确保了写变量的原子性,避免其他操作读到了修改变量过程中的脏数据。

  • 在原子地存储某个值的过程中,任何CPU都不会进行针对同一个值的读或写操作。
  • 原子的值存储操作总会成功,因为它并不会关心被操作值的旧值是什么
  • 和CAS操作有着明显的区别

实例演示:

package main

import (
	"fmt"
	"sync/atomic"
)

var value int32

func main() {
	fmt.Println("----------Store value----------")
	atomic.StoreInt32(&value, 10)
	fmt.Println(value)
}

运行结果:

[Running] go run "c:\Users\Mechrevo\Desktop\go_pro\test.go"
----------Store value----------
10

[Done] exited with code=0 in 1.481 seconds

你可能感兴趣的:(Go语言进阶学习笔记,学习,golang)