其他分享
首页 > 其他分享> > golang中的原子操作atomic包

golang中的原子操作atomic包

作者：互联网

1. 概念
 原子操作 atomic 包
 加锁操作涉及到内核态的上下文切换，比较耗时，代价高，
 针对基本数据类型我们还可以使用原子操作来保证并发的安全，
 因为原子操作是go语言提供的方法，我们在用户态就可以完成，因此性能比加锁操作更好
 go语言的原子操作由内置的库 sync/atomic 完成


2. atomic包
方法解释
func LoadInt32(addr int32) (val int32)
func LoadInt64(addr `int64) (val int64)<br>func LoadUint32(addruint32) (val uint32)<br>func LoadUint64(addruint64) (val uint64)<br>func LoadUintptr(addruintptr) (val uintptr)<br>func LoadPointer(addrunsafe.Pointer`) (val 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)		 写入操作
func AddInt32(addr *int32, delta int32) (new int32)
func AddInt64(addr *int64, delta int64) (new int64)
func AddUint32(addr *uint32, delta uint32) (new uint32)
func AddUint64(addr *uint64, delta uint64) (new uint64)
func AddUintptr(addr *uintptr, delta uintptr) (new uintptr)		 修改操作
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)		 交换操作
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)

 

3. 案例比较互斥锁和原子操作的性能

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))

}

　atomic包提供了底层的原子级内存操作，对于同步算法的实现很有用，这些函数必须谨慎的保证正确使用，除了某些特殊的底层应用，使用通道或者sync包的函数/类型实现同步更好

 

标签：int32,old,addr,原子,golang,int64,atomic,func,new
来源： https://www.cnblogs.com/mayanan/p/15532369.html