syncsync.WaitGroupsync.Mapsync.Pool

什么是原子操作？

原子操作是变量级别的互斥锁。

Mutexsync/atomic

我们可以用下图来表示：

vvv
sync/atomic

原子操作的使用场景是什么？

拿一个简单的例子来说明一下原子操作的使用场景：

我们可以在自己的电脑上运行一下这段代码，看看输出的结果是多少。 不出意外的话，应该每次可能都不一样，而且应该也不是 1000，这是为什么呢？

sumsumsumsum
sumsum

在这种场景下，我们可以使用原子操作来实现并发安全的加法操作：

在上面这个例子中，我们每次执行都能得到 1000 这个结果。

因为使用原子操作的时候，同一时刻只能有一个 CPU 对变量进行读或写，所以就不会出现上面的问题了。

所以很多需要对变量做并发读写的地方，我们都可以考虑一下，是否可以使用原子操作来实现并发安全的操作（而不是使用互斥锁，互斥锁效率相比原子操作要低一些）。

原子操作的使用场景也是和互斥锁类似的，但是不一样的是，我们的锁粒度只是一个变量而已。也就是说，当我们不允许多个 CPU 同时对变量进行读写的时候（保证变量同一时刻只能一个 CPU 操作），就可以使用原子操作。

原子操作是怎么实现的？

看完上面原子操作的介绍，有没有觉得原子操作很神奇，居然有这么好用的东西。那它到底是怎么实现的呢？

一般情况下，原子操作的实现需要特殊的 CPU 指令或者系统调用。 这些指令或者系统调用可以保证在执行期间不会被其他操作或事件中断，从而保证操作的原子性。

LOCKLOCKLOCK

x86 LOCK 的时候发生了什么

LOCK
  1. CPU 会将当前处理器缓存中的数据写回到内存中。（因此我们总能读取到最新的数据）
  2. 然后锁定该内存地址，防止其他 CPU 修改该地址的数据。
  3. 一旦当前 CPU 对该地址的操作完成，CPU 会释放该内存地址的锁定，其他 CPU 才能继续对该地址进行访问。

其他架构的 CPU 可能会略有不同，但是原理是一样的。

原子操作有什么特征？

  1. 不会被中断：原子操作是一个不可分割的操作，要么全部执行，要么全部不执行，不会出现中间状态。这是保证原子性的基本前提。同时，原子操作过程中不会有上下文切换的过程。
  2. 操作对象是共享变量：原子操作通常是对共享变量进行的，也就是说，多个协程可以同时访问这个变量，因此需要采用原子操作来保证数据的一致性和正确性。
  3. 并发安全：原子操作是并发安全的，可以保证多个协程同时进行操作时不会出现数据竞争问题（虽然说是同时，但是实际上在操作那个变量的时候是互斥的）。
  4. 无需加锁：原子操作不需要使用互斥锁来保证数据的一致性和正确性，因此可以避免互斥锁的使用带来的性能损失。
  5. 适用场景比较局限：原子操作适用于操作单个变量，如果需要同时并发读写多个变量，可能需要考虑使用互斥锁。

go 里面有哪些原子操作？

AddCompareAndSwapLoadStoreSwap

增减（Add）

Addint32int64uint32uint64uintptr
int32int64

比较并交换（CompareAndSwap）

CASCASoldnewaddrboolswap

也就是说，这个操作可能是不成功的。这很正常，在并发环境下，多个协程对同一个变量进行操作，肯定会存在竞争的情况。 在这种情况下，偶尔的失败是正常的，我们只需要在失败的时候，重新尝试即可。 因为原子操作需要的时间往往是比较短的，因此在失败的时候，我们可以通过自旋的方式来再次进行尝试。

在这种情况下，如果不自旋，那就需要将这个协程挂起，等待其他协程完成操作，然后再次尝试。这个过程相比自旋可能会更加耗时。 因为很有可能这次原子操作不成功，下一次就成功了。如果我们每次都将协程挂起，那么效率就会大大降低。

forsyncsync.Mapsync.Pool
CompareAndSwap
CompareAndSwapint32int64uint32uint64uintptrunsafe.Pointer

载入（Load）

原子性的读取操作接受一个对应类型的指针值，返回该指针指向的值。原子性读取意味着读取值的同时，当前计算机的任何 CPU 都不会进行针对值的读写操作。

Loadv := valuevvalue

Load 操作有下面这些：

存储（Store）

Storeval*addrStoreStore*addr
val*addrsync/atomicLoadStoreStore
Store

交换（Swap）

SwapStore*addr

原子操作任意类型的值 - atomic.Value

int32int64uint32uint64uintptrunsafe.Pointerstringstructatomic.Value
atomic.Valueany
atomic.Value
LoadValueStoreValueSwapValueCompareAndSwapValueoldnewValuetruefalse
atomic.Valueatomic.Valueatomic.Value

atomic.Value 源码分析

atomic.Value

Load - 读取

LoadStoreStorenil
atomic.ValueefaceWordsinterface{}/any
valvalefaceWords
int32int64uint32uint64uintptrunsafe.Pointerinterface{}interface{}interface{}typedatatypeinterface{}datainterface{}unsafe.Pointerinterface{}typedatainterface{}

Store - 存储

StoreValuevalStore(nil)panic
Store
firstStoreInProgressStoregoroutineStoregoroutinetypdatafirstStoreInProgressStorePfirstStoreInProgressStoreStorefirstStoreInProgressinterface{}firstStoreInProgressStoreStoreatomic.Value

Swap - 交换

SwapValuenewSwap(nil)panic

CompareAndSwap - 比较并交换

CompareAndSwapValueoldnewtruefalseCompareAndSwap(nil, nil)panic
data := LoadPointer(&vp.data)atomic.ValueCompareAndSwapPointer(&vp.data, old.data, np.data)CASoldinterface{}/anyolddatavp.dataCASfalse
interface{}interface{}interface{}
typdataanyi != oldinterface{}

其他原子类型

atomic.Valueint32int64uint32uint64uintptrunsafe.Pointer

对应的类型如下：

atomic.Booluint32atomic.Booluint32atomic.Int32int32atomic.Int64int64atomic.Uint32uint32atomic.Uint64uint64atomic.Uintptruintptratomic.Pointerunsafe.Pointer
atomic.Int32
atomic.Int32atomicint32

原子操作与互斥锁比较

那我们有了互斥锁，为什么还要有原子操作呢？我们进行比较一下就知道了：


原子操作互斥锁
保护的范围变量代码块
保护的粒度小大
性能高低
如何实现的硬件指令软件层面实现，逻辑较多

如果我们只需要对某一个变量做并发读写，那么使用原子操作就可以了，因为原子操作的性能比互斥锁高很多。 但是如果我们需要对多个变量做并发读写，那么就需要用到互斥锁了，这种场景往往是在一段代码中对不同变量做读写。

性能比较

我们前面这个表格提到了原子操作与互斥锁性能上有差异，我们写几行代码来进行比较一下：

MutexLock()UnLock()MutexAtomicsumAtomicMutex40%
MutexMutex40%Mutex

go 的 sync 包中的原子操作

sync.Mapsync.Pool

sync.Map 中的原子操作

sync.Mapentry
forCompareAndSwapentry

如果我们也需要对变量做并发读写，也可以尝试一下这种 for + CompareAndSwap 的组合。

sync.WaitGroup 中的原子操作

sync.WaitGroupatomic.Uint64stateWaitGroupWaitGroupWaitGroupWaiter

如果不使用一个变量来记录这两个值，那么我们就需要使用两个变量来记录，这样就会导致我们需要对两个变量做并发读写， 在这种情况下，我们就需要使用互斥锁来保护这两个变量，这样就会导致性能的下降。

而使用一个变量来记录这两个值，我们就可以使用原子操作来保护这个变量，这样就可以保证并发读写的安全性，同时也能得到更好的性能：

CAS 操作有失败必然有成功

CASCASsumCAS
atomic.AddInt32(&sum, 1)atomic.CompareAndSwapInt32(&sum, sum, sum+1)atomic.CompareAndSwapInt32(&sum, sum, sum+1)sumCASsumsum + 1
sumsumsumCASsumCAS

总结

原子操作是并发编程中非常重要的一个概念，它可以保证并发读写的安全性，同时也能得到更好的性能。

最后，总结一下本文讲到的内容：

AddCompareAndSwapLoadStoreSwapatomic.Valuesync.WaitGroupsync.MapentryCASCASCAS

总的来说，原子操作本身其实没有太复杂的逻辑，我们理解了它的原理之后，就可以很容易的使用它了。

推荐学习：Golang教程