GO 原子操作 atomic包

原子操作简介

原子操作即是进行过程中不能被中断的操作，针对某个值的原子操作在被进行的过程中，CPU绝不会再去进行其他的针对该值的操作。为了实现这样的严谨性，原子操作仅会由一个独立的CPU指令代表和完成。原子操作是无锁的，常常直接通过CPU指令直接实现。 事实上，其它同步技术的实现常常依赖于原子操作。

具体的原子操作在不同的操作系统中实现是不同的。比如在Intel的CPU架构机器上，主要是使用总线锁的方式实现的。 大致的意思就是当一个CPU需要操作一个内存块的时候，向总线发送一个LOCK信号，所有CPU收到这个信号后就不对这个内存块进行操作了。 等待操作的CPU执行完操作后，发送UNLOCK信号，才结束。 在AMD的CPU架构机器上就是使用MESI一致性协议的方式来保证原子操作。 所以我们在看atomic源码的时候，我们看到它针对不同的操作系统有不同汇编语言文件。

代码中的加锁操作因为涉及内核态的上下文切换会比较耗时、代价比较高。

针对基本数据类型我们还可以使用原子操作来保证并发安全，

因为原子操作是Go语言提供的方法它在用户态就可以完成，因此性能比加锁操作更好。

Go语言中原子操作由内置的标准库sync/atomic提供。

包中的方法

方法分成这几类：

• AddXXX：操作一个数字类型，加上一个数字
• LoadXXX：读取一个值
• CompareAndSwapXXX：比较并交换，大名鼎鼎的CAS操作
• StoreXXX：写入一个值
• SwapXXX：写入一个值，并且返回旧的值。 它和 CompareAndSwap 的区别在于它不关 心旧的值是什么
• unsafepointer 相关方法，不建议使用。难写 也难读，不到逼不得已不要去用，尤其是不要 为了优化而故意用 unsafepoint

使用案例

package main

import "sync/atomic"

var value int32 = 0

func main() {
	// 要传入 value 的指针
	// 把 value + 10
	atomic.AddInt32(&value, 10)
	nv := atomic.LoadInt32(&value)
	// 输出10
	println(nv)
	// 如果之前的值是10，那么就设置为新的值 20
	swapped := atomic.CompareAndSwapInt32(&value, 10, 20)
	// 输出 true
	println(swapped)

	// 如果之前的值是19，那么就设置为新的值 50
	// 显然现在 value 是 20
	swapped = atomic.CompareAndSwapInt32(&value, 19, 50)
	// 输出 false
	println(swapped)

	old := atomic.SwapInt32(&value, 40)
	// 应该是20，即原本的值
	println(old)
	// 输出新的值，也就是交换后的值，40
	println(value)
}

互斥锁和原子操作的性能比较

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
	"time"
)

var x int64
var l sync.Mutex
var wg sync.WaitGroup

// 普通版加函数
func add() {
	// x = x + 1
	x++ // 等价于上面的操作
	wg.Done()
}

// 互斥锁版加函数
func mutexAdd() {
	l.Lock()
	x++
	l.Unlock()
	wg.Done()
}

// 原子操作版加函数
func atomicAdd() {
	atomic.AddInt64(&x, 1)
	wg.Done()
}

func main() {
	start := time.Now()
	for i := 0; i < 10000; i++ {
		wg.Add(1)
		// go add() // 普通版add函数 不是并发安全的 9683 5.4649ms
		// go mutexAdd() // 加锁版add函数 是并发安全的，但是加锁性能开销大 10000 6.0296ms
		go atomicAdd() // 原子操作版add函数 是并发安全，性能优于加锁版 10000 5.5254ms
	}
	wg.Wait()
	end := time.Now()
	fmt.Println(x)
	fmt.Println(end.Sub(start))
}

原子操作与互斥锁的区别

首先atomic操作的优势是更轻量，比如CAS可以在不形成临界区和创建互斥量的情况下完成并发安全的值替换操作。这可以大大的减少同步对程序性能的损耗。

原子操作也有劣势。还是以CAS操作为例，使用CAS操作的做法趋于乐观，总是假设被操作值未曾被改变（即与旧值相等），并一旦确认这个假设的真实性就立即进行值替换，那么在被操作值被频繁变更的情况下，CAS操作并不那么容易成功。而使用互斥锁的做法则趋于悲观，我们总假设会有并发的操作要修改被操作的值，并使用锁将相关操作放入临界区中加以保护。

下面是几点区别：

• 互斥锁是一种数据结构，用来让一个线程执行程序的关键部分，完成互斥的多个操作
• 原子操作是无锁的，常常直接通过CPU指令直接实现
• 原子操作中的cas趋于乐观锁，CAS操作并不那么容易成功，需要判断，然后尝试处理
• 可以把互斥锁理解为悲观锁，共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程

atomic包提供了底层的原子性内存原语，这对于同步算法的实现很有用。这些函数一定要非常小心地使用，使用不当反而会增加系统资源的开销，对于应用层来说，最好使用通道或sync包中提供的功能来完成同步操作。

针对atomic包的观点在Google的邮件组里也有很多讨论，其中一个结论解释是：

应避免使用该包装。或者，阅读C ++ 11标准的“原子操作”一章；如果您了解如何在C ++中安全地使用这些操作，那么你才能有安全地使用Go的sync/atomic包的能力。

有关乐观锁，悲观锁，CAS等解释：

https://blog.csdn.net/weixin_50966947/article/details/124096601

https://www.jianshu.com/p/d2ac26ca6525