[TOC] # 简介 * 加锁代价比较耗时,需要上下文切换 * 针对基本数据类型,可以使用原子操作保证线程安全 * 原子操作在用户态就可以完成,因此性能比互斥锁要高 sync/atomic包中的函数可以做的原子操作有: * 加法(add) * 比较并交换(compare and swap,简称 CAS) * 加载(load) * 存储(store) * 交换(swap) 原子操作函数需要的是被操作值的指针,而不是这个值本身 **只要原子操作函数拿到了被操作值的指针**,就可以定位到存储该值的内存地址。只有这样,它们才能够通过底层的指令,准确地操作这个内存地址上的数据。 # 支持的类型 这些函数针对的数据类型并不多。但是,对这些类型中的每一个, sync/atomic包都会有一套函数给予支持。这些数据类型有:int32、int64、uint32、uint64、uintptr,以及unsafe包中的Pointer。 不过,针对unsafe.Pointer类型,该包并未提供进行原子加法操作的函数。 # 减法 atomic.AddInt32函数的第二个参数代表差量,它的类型是int32,是有符号的。如果我们想做原子减法,那么把这个差量设置为负整数就可以了。 对于atomic.AddInt64函数来说也是类似的。不过,要想用atomic.AddUint32和atomic.AddUint64函数做原子减法,就不能这么直接了,因为它们的第二个参数的类型分别是uint32和uint64,都是无符号的,不过,这也是可以做到的,就是稍微麻烦一些。 例如,如果想对uint32类型的被操作值18做原子减法,比如说差量是\-3,那么我们可以先把这个差量转换为有符号的int32类型的值,然后再把该值的类型转换为uint32,用表达式来描述就是uint32(int32(-3))。 不过要注意,直接这样写会使 Go 语言的编译器报错,它会告诉你:“常量\-3不在uint32类型可表示的范围内”,换句话说,这样做会让表达式的结果值溢出。 不过,如果我们先把int32(-3)的结果值赋给变量delta,再把delta的值转换为uint32类型的值,就可以绕过编译器的检查并得到正确的结果了。 最后,我们把这个结果作为atomic.AddUint32函数的第二个参数值,就可以达到对uint32类型的值做原子减法的目的了。 还有一种更加直接的方式。我们可以依据下面这个表达式来给定atomic.AddUint32函数的第二个参数值: ~~~ ^uint32(-N-1)) ~~~ 其中的N代表由负整数表示的差量。也就是说,我们先要把差量的绝对值减去1,然后再把得到的这个无类型的整数常量,转换为uint32类型的值,最后,在这个值之上做按位异或操作,就可以获得最终的参数值了。 这么做的原理也并不复杂。简单来说,此表达式的结果值的补码,与使用前一种方法得到的值的补码相同,所以这两种方式是等价的。我们都知道,整数在计算机中是以补码的形式存在的,所以在这里,结果值的补码相同就意味着表达式的等价 # 比较并交换和交换操作相比有什么不同? 比较并交换操作即 CAS 操作,是有条件的交换操作,只有在条件满足的情况下才会进行值的交换。 所谓的交换指的是,把新值赋给变量,并返回变量的旧值。 在进行 CAS 操作的时候,函数会先判断被操作变量的当前值,是否与我们预期的旧值相等。如果相等,它就把新值赋给该变量,并返回true以表明交换操作已进行;否则就忽略交换操作,并返回false。 可以看到,CAS 操作并不是单一的操作,而是一种操作组合。这与其他的原子操作都不同。正因为如此,它的用途要更广泛一些。例如,我们将它与for语句联用就可以实现一种简易的自旋锁(spinlock)。 ~~~ for { if atomic.CompareAndSwapInt32(&num2, 10, 0) { fmt.Println("The second number has gone to zero.") break } time.Sleep(time.Millisecond * 500) } ~~~ for语句加 CAS 操作的假设往往是:共享资源状态的改变并不频繁,或者,它的状态总会变成期望的那样。这是一种更加乐观,或者说更加宽松的做法。 # 方法 目前只支持int类型 ![](https://box.kancloud.cn/8ae6837c756e60b10e9cdae283bc827e_769x781.png) ~~~ import ( "fmt" "sync" "sync/atomic" ) var x int32 var wg sync.WaitGroup func add() { for i := 0; i<5000; i++ { //x = x+1 atomic.AddInt32(&x, 1) } defer wg.Done() } func main() { wg.Add(2) //各加5000 go add() go add() wg.Wait() //结果一定是10000 fmt.Println(x) } ~~~ # 自旋锁 ~~~ // forAndCAS1 用于展示简易的自旋锁。 func forAndCAS1() { sign := make(chan struct{}, 2) num := int32(0) fmt.Printf("The number: %d\n", num) go func() { // 定时增加num的值。 defer func() { sign <- struct{}{} }() for { time.Sleep(time.Millisecond * 500) newNum := atomic.AddInt32(&num, 2) fmt.Printf("The number: %d\n", newNum) if newNum == 10 { break } } }() go func() { // 定时检查num的值,如果等于10就将其归零。 defer func() { sign <- struct{}{} }() for { if atomic.CompareAndSwapInt32(&num, 10, 0) { fmt.Println("The number has gone to zero.") break } time.Sleep(time.Millisecond * 500) } }() <-sign <-sign } ~~~ # atomic.value atomic.Value分为两个操作,通过Store()存储Value,通过Load()来读取Value的值. ~~~ package main import ( "fmt" "sync/atomic" ) type Value struct { key string Val interface{} } type Noaway struct { Movies atomic.Value Total atomic.Value } func NewNoaway() *Noaway { n := new(Noaway) n.Movies.Store(&Value{key: "movie", Val: "Wolf Warrior 2"}) n.Total.Store("123") return n } func main() { n := NewNoaway() val := n.Movies.Load().(*Value) total := n.Total.Load().(string) fmt.Printf("%#v --- %#v\n", val, total) } ~~~ ## 如何用好atomic.value 第一条规则,不能用原子值存储nil。 也就是说,我们不能把nil作为参数值传入原子值的Store方法,否则就会引发一个 panic。 这里要注意,如果有一个接口类型的变量,它的动态值是nil,但动态类型却不是nil,那么它的值就不等于nil。我在前面讲接口的时候和你说明过这个问题。正因为如此,这样一个变量的值是可以被存入原子值的。 第二条规则,我们向原子值存储的第一个值,决定了它今后能且只能存储哪一个类型的值。 例如,我第一次向一个原子值存储了一个string类型的值,那我在后面就只能用该原子值来存储字符串了。如果我又想用它存储结构体,那么在调用它的Store方法的时候就会引发一个 panic。这个 panic 会告诉我,这次存储的值的类型与之前的不一致。 你可能会想:我先存储一个接口类型的值,然后再存储这个接口的某个实现类型的值,这样是不是可以呢? 很可惜,这样是不可以的,同样会引发一个 panic。因为原子值内部是依据被存储值的实际类型来做判断的。所以,即使是实现了同一个接口的不同类型,它们的值也不能被先后存储到同一个原子值中。 遗憾的是,我们无法通过某个方法获知一个原子值是否已经被真正使用,并且,也没有办法通过常规的途径得到一个原子值可以存储值的实际类型。这使得我们误用原子值的可能性大大增加,尤其是在多个地方使用同一个原子值的时候。 下面,我给你几条具体的使用建议。 1. 不要把内部使用的原子值暴露给外界。比如,声明一个全局的原子变量并不是一个正确的做法。这个变量的访问权限最起码也应该是包级私有的。 2. 如果不得不让包外,或模块外的代码使用你的原子值,那么可以声明一个包级私有的原子变量,然后再通过一个或多个公开的函数,让外界间接地使用到它。注意,这种情况下不要把原子值传递到外界,不论是传递原子值本身还是它的指针值。 3. 如果通过某个函数可以向内部的原子值存储值的话,那么就应该在这个函数中先判断被存储值类型的合法性。若不合法,则应该直接返回对应的错误值,从而避免 panic 的发生。 4. 如果可能的话,我们可以把原子值封装到一个数据类型中,比如一个结构体类型。这样,我们既可以通过该类型的方法更加安全地存储值,又可以在该类型中包含可存储值的合法类型信息。 除了上述使用建议之外,我还要再特别强调一点:尽量不要向原子值中存储引用类型的值。因为这很容易造成安全漏洞。请看下面的代码: ~~~ var box6 atomic.Value v6 := []int{1, 2, 3} box6.Store(v6) v6[1] = 4 // 注意,此处的操作不是并发安全的! ~~~ 我把一个[]int类型的切片值v6, 存入了原子值box6。注意,切片类型属于引用类型。所以,我在外面改动这个切片值,就等于修改了box6中存储的那个值。这相当于绕过了原子值而进行了非并发安全的操作。那么,应该怎样修补这个漏洞呢?可以这样做: ~~~ store := func(v []int) { replica := make([]int, len(v)) copy(replica, v) box6.Store(replica) } store(v6) v6[2] = 5 // 此处的操作是安全的 ~~~