Go教程

Go语言并发编程:原子操作

本文主要是介绍Go语言并发编程:原子操作,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

在程序执行过程中,操作系统会进行线程调度,同一时刻能同时执行的程序数量跟CPU的内核线程数有关,比如4核CPU,同时最多只能有4个线程。Go 语言中的运行时系统也会对goroutine进行调度,调度器会频繁地让goroutine处于中断或者运行状态,这就不能保证代码执行的原子性(atomicity),即使使用互斥锁也不能保证原子性操作。Go语言中的atomic包提供了原子操作方法,下面来介绍它的使用方法。

目录
  • atomic原子操作类型和方法
  • Add 增加
  • Load 加载
  • Store 存储
  • Swap 交换
  • CompareAndSwap 比较并交换
  • atomic.Value
  • 总结

原子操作过程中是不允许中断的,是绝对并发安全的。由于原子操作不允许中断,所以它非常影响系统执行效率,因此,Go 语言的sync/atomic包只针对少数数据类型提供了原子操作函数。

atomic原子操作类型和方法

支持的数据类型主要有7个:int32、int64、uint32、uint64、uintptr,Pointer(unsafe包)以及Value类型,Value类型可以用来存储任意类型的值。

对这些类型的操作函数包括:

  • 增加 (Add):atomic.AddInt32(addr *int32, delta int32)
  • 加载(Load):atomic.LoadInt32(addr *int32)
  • 存储(Store):atomic.LoadInt32(addr *int32)
  • 交换(Swap):atomic.SwapInt32(addr *int32, new int32)
  • 比较并交换(CompareAndSwap): atomic.CompareAndSwapInt32(addr *int32, old int32, new int32)

其中,unsafe.Pointer类型没有add操作,Value类型只要Load和Store两个方法。

注意,第一个参数值为被操作值的指针,原子操作根据指针定位到该值的内存地址,操作这个内存地址上的数据。

Add 增加

Add可以用于增加操作:

package main

import (
	"fmt"
	"sync/atomic"
)

func main() {
	num := int32(20)
	atomic.AddInt32(&num, 3)
	fmt.Println(num)  // 23
}

Add也可以做减法操作,其中AddInt32的第二个参数int32是有符号整型,所以delta值设置为负整数就是减法操作了。

num := int32(18)
atomic.AddInt32(&num, -3)
fmt.Println(num)

而uint32和uint64是无符号的,如果想对这两种类型做减法操作需要做一下转换,比如先把delta值转换为有符号类型,然后再转换为无符号类型:

num := uint32(18)
delta := int32(-3)
atomic.AddUint32(&num, uint32(delta))
fmt.Println(num)

也可以使用如下方式:

atomic.AddUint32(&num, ^uint32(-(-3)-1))

Load 加载

Load可以实现对值的原子读取:

num := int32(20)
atomic.LoadInt32(&num)
fmt.Println(atomic.LoadInt32(&num))

Store 存储

原子的存储某个值:

num := int32(20)
atomic.StoreInt32(&num, 30)
fmt.Println(num) // 30

Swap 交换

将新的值赋给被操作的旧值,并返回旧值

num := int32(20)
old := atomic.SwapInt32(&num, 60)
fmt.Println(num) // 60
fmt.Println(old) // 20

CompareAndSwap 比较并交换

比较并交换(Compare And Swap,CAS操作 )和交换(Swap)不同,会先进行比较,满足条件后再进行交换操作,将新值赋给变量。返回值为true或者false,true表示执行了交换操作。

num:= int32(18)
atomic.CompareAndSwapInt32(&num, 20, 0)
fmt.Printf("The number: %d\n", num)
atomic.CompareAndSwapInt32(&num, 18, 0)
fmt.Printf("The number: %d\n", num)

执行结果:

The number: 18
The number: 0

CAS操作可以用来实现自旋锁(spinlock),下面先来介绍一下什么是自旋锁,自旋锁和互斥锁都可以用来保护共享资源,它们的区别在于,资源被互斥锁锁定时,其它要操作资源的线程会进入睡眠状态;如果是自旋锁,线程将循环等待,不会释放cpu,直到获取到锁才会退出循环。由于自旋锁的这种特性,一般会对等待时间或者尝试次数进行一定的限制。

由于自旋锁不需要进行上下文切换,它的效率比互斥锁高,适用于保持锁的时间比较短,并且不会频繁操作共享资源的场景。

下面的代码实现一个简单的自旋锁,存满10000后全部取出:

package main

import (
	"fmt"
	"sync/atomic"
	"time"
	"sync"
)

var (
    balance int32
	wg sync.WaitGroup
)

// 存钱
func deposit(value int32) {
	for {
		
		fmt.Printf("余额: %d\n", balance)
		atomic.AddInt32(&balance, value)
		fmt.Printf("存 %d 后的余额: %d\n", value, balance)
		fmt.Println()
		if balance == 10000 {
			break
		}
		time.Sleep(time.Millisecond * 500)
	}
    wg.Done()
}

// 取钱
func withdrawAll(value int32) {
    defer wg.Done()
	
	for {
		if atomic.CompareAndSwapInt32(&balance, value, 0) {
			break
		}
		time.Sleep(time.Millisecond * 500)
	}
	fmt.Printf("余额: %d\n", value)
    fmt.Printf("取 %d 后的余额: %d\n", value, balance)
    fmt.Println()    
}

func main() {
	wg.Add(2)	
	go deposit(1000)  // 每次存1000
	go withdrawAll(10000)
    wg.Wait()

    fmt.Printf("当前余额: %d\n", balance)
}

func init() {
    balance = 1000 // 初始账户余额为1000    
}

atomic.Value

Value类型可以被用来“原子地”存储(Store)和加载(Load)任意的值。

var valu atomic.Value
valu := [...]int{1, 2, 3}
box.Store(valu)
fmt.Println(valu.Load())

使用Value类型时需要注意以下事项:

1、Value不能用来存储nil值。

2、一个Value变量不能存储不同类型的值,存储的类型只能是第一个存储值的类型。

var box atomic.Value
v1 := "123"
box.Store(v1)
v2 := 123	
box.Store(v2)

上面的写法会引发一个panic:panic: sync/atomic: store of inconsistently typed value into Value

3、尽量不要使用Value存储引用类型的值。

先来看下面的例子:

package main

import (
	"fmt"
	"sync/atomic"
)

func main() {
    var valu atomic.Value
    v1 := []int{1, 2, 3}
    valu.Store(v1)
    fmt.Println(valu.Load())
    v1[1] = 6
    fmt.Println(valu.Load())
}

执行结果:

[1 2 3]
[1 6 3]

修改引用类型的值相当于修改了valu中存储的值,可以使用深拷贝copy方法来解决这个漏洞:

package main

import (
	"fmt"
	"sync/atomic"
)

func main() {
    var valu atomic.Value
    v1 := []int{1, 2, 3}
	store := func(v []int) {
		replica := make([]int, len(v))
		copy(replica, v)
		valu.Store(replica)
	}
	fmt.Printf("Store %v to box6.\n", v6)
	store(v1)
	fmt.Println(valu.Load())
    v1[1] = 6
    fmt.Println(valu.Load())
}

执行结果:

[1 2 3]
[1 2 3]

总结

原子操作函数支持的数据类型有限,互斥锁可能使用的场景更多一些,在可以使用原子操作的情况下还是建议使用它,因为相对来说原子操作函数的执行速度比互斥锁快,且使用简单。另外在使用 CAS 操作时,要防止进入死循环,导致“阻塞”流程。

在使用Value类型时要注意尽量不要存储引用类型的值,是非并发安全的。

--THE END--
这篇关于Go语言并发编程:原子操作的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!