Golang 中 sync/atomic 包的原子操作

背景

Go中多协程的情况下， 要保证操作的原子性，一般要使用RWMutex或者Mutex， 但是锁使用起来比较复杂，还要考虑lock 和unlock 顺序和成对出现，不注意就容易出错。
于是在sync/atomic包中，把我们常用的一些操作封装成原子操作，提供了更加轻量级的解决方案

Add 方法

简介

提供了将两个操作数相加的方法， 共有以下方法

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

这里的 AddUint32, AddUint64, AddUintptr 的参数是无符号类型, 标识可以使用 - 来进行减法操作

示例

package main

import (
	"fmt"
	"sync/atomic"
	"time"
)
func main() {
	// 加法案例
	var count int32
	for i:= 0;i < 100 ; i++{
		go func() { atomic.AddInt32(&count,1) }()
	}
	// 等待协程执行完
	time.Sleep(5*time.Second)
	fmt.Println("ADD count:", count)
	// 减法案例
	var sub_param1  uint32 = 100
	var sub_param2  uint32 = 1
	for i:= 0;i < 100 ; i++{
			// 添加了 - , 表示减法, 只能作用于无符号类型变量
		go func() { atomic.AddUint32(&sub_param1,-sub_param2)}()
	}
	// 等待协程执行完
	time.Sleep(5*time.Second)
	fmt.Println("SUB sub_param1:", sub_param1)
}

执行结果:

可以看到, 使用atomic操作更加简洁和方便.

其他方法

类似于Add, atomic 也提供了其他原子操作方法

Swap 方法,Swap 方法的功能是原值替换为新值，并返回原值。

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)

CompareAndSwap 方法,功能是比较 addr 和 old, 相等将addr的值替换为new, 返回值是是否进行了替换.

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)

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)

Store 方式是写入操作, 将val写入 addr

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)

还有一个属于Value类型的方法, 可以存取任何类型的数据, 相当于一个数据存取空间, 但是同一个 Value 类型的实例，只能存取一种类型的数据, 只要调用过一次 Store 方法，那么传入此方法的后续参数类型必须和之前传入参数的类型一致，否则会导致 panic

func (v *Value) Load() (x interface{})
func (v *Value) Store(x interface{})