Go语言在设计上对同步(Synchronization,数据同步和线程同步)提供大量的支持,比如 goroutine和channel同步原语,库层面有
atomic
当我们想要对某个变量并发安全的修改,除了使用官方提供的 mutex,还可以使用 sync/atomic 包的原子操作,它能够保证对变量的读取或修改期间不被其他的协程所影响。
atomic 包的原子操作是通过 CPU 指令,也就是在硬件层次去实现的,性能较好,不需要像 mutex 那样记录很多状态。 当然,mutex 不止是对变量的并发控制,更多的是对代码块的并发控制,2 者侧重点不一样。
atomic 这些功能需要非常小心才能正确使用。 除了特殊的低级应用程序外,最好使用通道或同步包的工具来完成同步。 通过通信共享内存; 不要通过共享内存进行通信。
atomic 包有几种原子操作,主要是 Add、CompareAndSwap、Load、Store、Swap
atomic 的 Add 是针对 int 和 uint 进行原子加值的:
当需要添加的值为负数的时候,做减法,正数做加法
func AddInt32(addr *int32, delta int32) (new int32)
func AddUint32(addr *uint32, delta uint32) (new uint32)
func AddInt64(addr *int64, delta int64) (new int64)
func AddUint64(addr *uint64, delta uint64) (new uint64)
func AddUintptr(addr *uintptr, delta uintptr) (new uintptr)
比较并交换方法实现了类似乐观锁的功能,只有原来的值和传入的 old 值一样,才会去修改,
CAS 操作, 会先比较传入的地址的值是否是 old,如果是的话就尝试赋新值,如果不是的话就直接返回 false,返回 true 时表示赋值成功。
func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)
func CompareAndSwapInt64(addr *int64, old, new int64) (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)
func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)
需要注意的是,CompareAndSwap 有可能产生ABA现象发生。也就是原来的值是 A,后面被修改 B,再后面修改为 A。在这种情况下也符合了 CompareAndSwap 规则,即使中途有被改动过。
从某个地址中取值
Load 方法是为了防止在读取过程中,有其他协程发起修改动作,影响了读取结果,常用于配置项的整个读取。
func LoadInt32(addr *int32) (val int32)
func LoadInt64(addr *int64) (val int64)
func LoadUint32(addr *uint32) (val uint32)
func LoadUint64(addr *uint64) (val uint64)
func LoadUintptr(addr *uintptr) (val uintptr)
func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)
给某个地址赋值
有原子读取,就有原子修改值,前面提到过的 Add 只适用于 int、uint 类型的增减,并没有其他类型的修改,而 Sotre 方法通过 unsafe.Pointer 指针原子修改,来达到了对其他类型的修改。
func StoreInt32(addr *int32, val int32)
func StoreInt64(addr *int64, val int64)
func StoreUint32(addr *uint32, val uint32)
func StoreUint64(addr *uint64, val uint64)
func StoreUintptr(addr *uintptr, val uintptr)
func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer)
交换两个值,并且返回老的值
Swap 方法实现了对值的原子交换,不仅 int,uint 可以交换,指针也可以。
func SwapInt32(addr *int32, new int32) (old int32)
func SwapInt64(addr *int64, new int64) (old int64)
func SwapUint32(addr *uint32, new uint32) (old uint32)
func SwapUint64(addr *uint64, new uint64) (old uint64)
func SwapUintptr(addr *uintptr, new uintptr) (old uintptr)
func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)
value类型
最后一类Value 用于任意类型的值的 Store、Load,我们开始的案例就用到了这个,这是 1.4 版本之后引入的,签名的方法都只能作用于特定的类型,引入这个方法之后就可以用于任意类型了。
sync/atomic标准库包也提供了一个Value类型,以它为基的指针类型*Value拥有四个方法(见下,其中后两个是从Go 1.17开始才支持的)。Value值用来原子读取和修改任何类型的Go值。
func (*Value) Load() (x interface{})
func (*Value) Store(x interface{})
func (*Value) Swap(new interface{}) (old interface{})
func (*Value) CompareAndSwap(old, new interface{}) (swapped bool)
在 sync/atomic 包中的源码除了 Value 之外其他的函数都是没有直接的源码的,需要去 runtime/internal/atomic 中找寻,这里为 CAS 函数为例,其他的都是大同小异
// bool Cas(int32 *val, int32 old, int32 new)
// Atomically:
// if(*val == old){
// *val = new;
// return 1;
// } else
// return 0;
TEXT runtime internal atomic·Cas(SB),NOSPLIT,$0-17
MOVQ ptr+0(FP), BX
MOVL old+8(FP), AX
MOVL new+12(FP), CX
LOCK
CMPXCHGL CX, 0(BX)
SETEQ ret+16(FP)
RET
在注释部分写的非常清楚,这个函数主要就是先比较一下当前传入的地址的值是否和 old 值相等,如果相等,就赋值新值返回 true,如果不相等就返回 false
我们看这个具体汇编代码就可以发现,使用了LOCK 来保证操作的原子性,CMPXCHG 指令其实就是 CPU 实现的 CAS 操作。
//Go语言在设计上对同步(Synchronization,数据同步和线程同步)提供大量的支持,比如 goroutine和channel同步原语,库层面有
//
//
//- sync:提供基本的同步原语(比如Mutex、RWMutex、Locker)和 工具类(Once、WaitGroup、Cond、Pool、Map)
//- sync/atomic:提供变量的原子操作(基于硬件指令 compare-and-swap)
package main
import (
"fmt"
"sync"
"sync/atomic"
"time"
)
var (
x int64
mx sync.Mutex
wg sync.WaitGroup
)
// 普通函数, 并发不安全
func Add() {
x++
wg.Done()
}
// 互斥锁, 并发安全,性能低于原子操作
func MxAdd() {
mx.Lock()
x++
mx.Unlock()
wg.Done()
}
// 原子操作,并发安全,性能高于互斥锁,只针对go中的一些基本数据类型使用
func AmAdd() {
atomic.AddInt64(&x, 1)
wg.Done()
}
func main() {
// 原子操作atomic包
// 加锁操作涉及到内核态的上下文切换, 比较耗时,代价高
// 针对基本数据类型我们还可以使用原子操作来保证并发安全
// 因为原子操作是go语言提供的方法,我们在用户态就可以完成,因此性能比加锁操作更好
// go语言的原子操作由内置的库,sync/atomic完成
start := time.Now()
for i := 0; i < 10000; i++ {
wg.Add(1)
go Add() // 普通版Add函数不是并发安全的
//go MxAdd() // 加锁版Add函数,是并发安全的, 但是加锁性能开销大
//go AmAdd() // 原子操作版Add函数,是并发安全的,性能优于加锁版
}
end := time.Now()
wg.Wait()
fmt.Println(x)
fmt.Println(end.Sub(start))
}
//Go语言在设计上对同步(Synchronization,数据同步和线程同步)提供大量的支持,比如 goroutine和channel同步原语,库层面有
//
//
//- sync:提供基本的同步原语(比如Mutex、RWMutex、Locker)和 工具类(Once、WaitGroup、Cond、Pool、Map)
//- sync/atomic:提供变量的原子操作(基于硬件指令 compare-and-swap)
package main
import (
"fmt"
"sync"
"sync/atomic"
"time"
)
var (
x int64
mx sync.Mutex
wg sync.WaitGroup
)
// 普通函数, 并发不安全
func Add() {
x++
wg.Done()
}
// 互斥锁, 并发安全,性能低于原子操作
func MxAdd() {
mx.Lock()
x++
mx.Unlock()
wg.Done()
}
// 原子操作,并发安全,性能高于互斥锁,只针对go中的一些基本数据类型使用
func AmAdd() {
atomic.AddInt64(&x, 1)
wg.Done()
}
func main() {
// 原子操作atomic包
// 加锁操作涉及到内核态的上下文切换, 比较耗时,代价高
// 针对基本数据类型我们还可以使用原子操作来保证并发安全
// 因为原子操作是go语言提供的方法,我们在用户态就可以完成,因此性能比加锁操作更好
// go语言的原子操作由内置的库,sync/atomic完成
start := time.Now()
for i := 0; i < 10000; i++ {
wg.Add(1)
// go Add() // 普通版Add函数不是并发安全的
go MxAdd() // 加锁版Add函数,是并发安全的, 但是加锁性能开销大
//go AmAdd() // 原子操作版Add函数,是并发安全的,性能优于加锁版
}
end := time.Now()
wg.Wait()
fmt.Println(x)
fmt.Println(end.Sub(start))
}
//Go语言在设计上对同步(Synchronization,数据同步和线程同步)提供大量的支持,比如 goroutine和channel同步原语,库层面有
//
//
//- sync:提供基本的同步原语(比如Mutex、RWMutex、Locker)和 工具类(Once、WaitGroup、Cond、Pool、Map)
//- sync/atomic:提供变量的原子操作(基于硬件指令 compare-and-swap)
package main
import (
"fmt"
"sync"
"sync/atomic"
"time"
)
var (
x int64
mx sync.Mutex
wg sync.WaitGroup
)
// 普通函数, 并发不安全
func Add() {
x++
wg.Done()
}
// 互斥锁, 并发安全,性能低于原子操作
func MxAdd() {
mx.Lock()
x++
mx.Unlock()
wg.Done()
}
// 原子操作,并发安全,性能高于互斥锁,只针对go中的一些基本数据类型使用
func AmAdd() {
atomic.AddInt64(&x, 1)
wg.Done()
}
func main() {
// 原子操作atomic包
// 加锁操作涉及到内核态的上下文切换, 比较耗时,代价高
// 针对基本数据类型我们还可以使用原子操作来保证并发安全
// 因为原子操作是go语言提供的方法,我们在用户态就可以完成,因此性能比加锁操作更好
// go语言的原子操作由内置的库,sync/atomic完成
start := time.Now()
for i := 0; i < 10000; i++ {
wg.Add(1)
// go Add() // 普通版Add函数不是并发安全的
// go MxAdd() // 加锁版Add函数,是并发安全的, 但是加锁性能开销大
go AmAdd() // 原子操作版Add函数,是并发安全的,性能优于加锁版
}
end := time.Now()
wg.Wait()
fmt.Println(x)
fmt.Println(end.Sub(start))
}
原子操作是比其它同步技术更基础的操作。原子操作是无锁的,常常直接通过CPU指令直接实现。 事实上,其它同步技术的实现常常依赖于原子操作。例如上面的的mx.lock
atomic包提供了底层的内存操作,对于同步算法的实现很有用, 这些函数必须谨慎的保证正确使用,除了某些特殊的底层应用,使用通道或者sync包的函数/ 类型实现同步更好
atomic 很多时候可能都没有使用上,毕竟 mutex 的拓展性比较好,使用起来也比较友好。但这并不妨碍我们对极致性能的追求,有时候,细节决定了性能!
页面更新:2024-05-12
本站资料均由网友自行发布提供,仅用于学习交流。如有版权问题,请与我联系,QQ:4156828
© CopyRight 2008-2024 All Rights Reserved. Powered By bs178.com 闽ICP备11008920号-3
闽公网安备35020302034844号