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(addr`uint32`) (val uint32)<br>func LoadUint64(addr`uint64`) (val uint64)<br>func LoadUintptr(addr`uintptr`) (val uintptr)<br>func LoadPointer(addr`unsafe.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))
 
}