sync/atomic 原子操作使用与解析

                <svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
                    <path stroke-linecap="round" d="M5,0 0,2.5 5,5z" id="raphael-marker-block" style="-webkit-tap-highlight-color: rgba(0, 0, 0, 0);"></path>
                </svg>
                <p></p>

目录

• 前言
• 1. 引入
• 2. sync.atomic 原子操作
• • 2.1 什么是原子操作
  • 2.2 各种 API 的作用
  • • 2.2.1 Store 操作
    • 2.2.2 Load 操作
    • 2.2.3 Add 操作
    • 2.2.4 Swap 操作
    • 2.2.5 CompareAndSwap 操作
• 3. atomic.Value 解析
• • 3.1 API 作用

前言

Go 源码版本：1.16
如果本文对你有帮助，给个赞吧；
喜欢本文就收藏一下吧；
有问题欢迎评论留言，基本都会回。

1. 引入

下面这段程序输出是多少呢？

package main
import (

"fmt"

"time"

)
var a int = 0
func main() {

for i := 0; i < 1000; i++ {

go func() {

a++

}()

}

fmt.Printf("a = %d\n", a)

time.Sleep(time.Second)

}

在 main 协程中开 1000 个协程，每个协程都是对全局变量 a 进行自加操作，看起来输出应该会是 1000，但你可以多运行几次，你会发现输出几乎没有 1000！
根本原因是 a++ 并不是原子操作。
a++ 从开始到完成可以分成 3 步：

1. 从主存读出 a 送到 CPU；
2. CPU 进行 a = a + 1；
3. CPU 将新的 a 写回主存。

这样一来 1000 个协程并发执行时有可能读到相同的 a 值，也就是说每个协程读到的 a 可能不是期望中最新的 a（第 2 个协程期望读到最新的 a = 1）

2. sync.atomic 原子操作

2.1 什么是原子操作

为了得到 1000，我们必须让以上 3 步在执行时一气呵成，不可中断，要么都执行了，要么都没执行。
从上面这句话引出原子性和原子操作的概念：

1. 原子性：一个或多个操作在 CPU 执行过程中不可中断的特性。
2. 原子操作：不会被线程调度打断的操作。

因此原子操作从表现上看，就是一气呵成，不可中断，要么都执行了，要么都没执行。

那么原子操作是如何实现的呢？
一顿搜索操作后，我知道了，作为程序员，仅需要知道是通过底层硬件支持实现的即可。
（我个人的理解是根据硬件特性编写的一段汇编代码来实现的，因此不同的 CPU 架构的实现略有差异）

当我们打开 $GOROOT/src/sync/atomic 下的查看源码时，发现只有几个函数，并没有具体实现，如下图：

但是我们看到 asm.s 文件里，好像当我们调用上图的 API 时，会跳到 runtime/internal/atomic 里去执行。

那么就打开看看里面有什么。我随便打开了一个 amd64 架构的版本，出现在我眼前的就是这一段汇编代码！

2.2 各种 API 的作用

作为一个程序员，我实在是不想知道底层硬件是如何实现原子操作的，我只会调 API（哎，有脑子就是不用，我就是玩= =）。

我们可以将 API 分为 5 大类：

1. StoreXXX：存储操作
2. LoadXXX：加载操作
3. AddXXX：加法操作
4. SwapXXX：交换操作
5. CompareAndSwapXXX：比较与交换操作

其中 XXX 代表 API 支持的各种数据类型，从函数名上我们很容易看出，以上 5 大类操作都支持 6 种数据类型：int32, int64, uint32, uint64, uintptr 和 unsafe.Pointer（唯一例外的是 Add 操作不支持 unsafe.Pointer 类型）
前面 4 种类型都很容易理解，后面 2 种的意思如下：

// uintptr is an integer type that is large enough to hold the bit pattern of
// any pointer.
type uintptr uintptr

无情翻译：uintptr 是一种足够大、能容纳任何长度比特模式的指针的整型。

type ArbitraryType int
type Pointer *ArbitraryType
// int is a signed integer type that is at least 32 bits in size. It is a

// distinct type, however, and not an alias for, say, int32.

type int int

无情翻译：unsafe.Pointer 其实就是 *int 的别名，而在 go 中 int 是至少 32 位、可变长度的有符号整型（易知最长是 64 位= =）

以下内容引自：atomic 包的使用及解析
Go 语言并不支持直接操作内存，但是它的标准库提供一种不保证向后兼容的指针类型 unsafe.Pointer，让程序可以灵活的操作内存，它的特别之处在于：可以绕过 Go 语言类型系统的检查。
也就是说：如果两种类型具有相同的内存结构，我们可以将 unsafe.Pointer 当作桥梁，让这两种类型的指针相互转换，从而实现同一份内存拥有两种解读方式。
例如 int 类型和 int32 类型内部的存储结构是一致的，但是对于指针类型的转换需要这么做：

var a int32
// 获得a的*int类型指针
(*int)(unsafe.Pointer(&a))

2.2.1 Store 操作

// StoreInt32 atomically stores val into *addr.
func StoreInt32(addr *int32, val int32)

将 val 存储到地址 addr 指向的内存单元，用一行代码表示它的作用就是 *addr = val。
例子：将 4 存储到变量 a 中

var a int32 = 0
atomic.StoreInt32(&a, 4)

2.2.2 Load 操作

// LoadInt32 atomically loads *addr.
func LoadInt32(addr *int32) (val int32)

读取地址 addr 所指向的内存单元中的内容并返回。
例子：读取变量 a 的值

 var a int32 = 0
 atomic.LoadInt32(&a)

2.2.3 Add 操作

// AddInt32 atomically adds delta to *addr and returns the new value.
func AddInt32(addr *int32, delta int32) (new int32)

将 delta 加到 addr 所指内存单元中并返回新的结果。
例子：将变量 a=0 加 2 之后返回新结果

var a int32 = 0
fmt.Println(atomic.AddInt32(&a, 2))		// 2

2.2.4 Swap 操作

// SwapInt32 atomically stores new into *addr and returns the previous *addr value.
func SwapInt32(addr *int32, new int32) (old int32)

将 new 存储到 addr 所指内存单元中，并返回内存单元中的旧值。
例子：将变量 a=1 改为 3

var a int32 = 1
fmt.Println(atomic.SwapInt32(&a, 3))    // 返回旧值 1
fmt.Println(a)  // 新值 3

2.2.5 CompareAndSwap 操作

// CompareAndSwapInt32 executes the compare-and-swap operation for an int32 value.
func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)

用代码来表示作用：

if *addr == old {
	*addr = new
	return true
} else {
	return false
}

例子：

var a int32 = 1
// 因为 a 原本是 1，比较失败不交换，输出 false
fmt.Println(atomic.CompareAndSwapInt32(&a, 2, 3))  // false  
fmt.Println(a)  // 比较失败，没发生交换，因此还是 1
fmt.Println(atomic.CompareAndSwapInt32(&a, 1, 3))   // true
fmt.Println(a)  // 3

注：CompareAndSwap 简称 CAS 操作。

3. atomic.Value 解析

前面翻译了一下常用的 5 大原子操作的作用，但在 atomic 包内还有一个 atomic.Value 类型，这是用来做什么的呢？

type Value struct {
	v interface{}
}

从内部 v 的类型 interface{} 可以看出这是为了扩大存储范围，支持任意类型的存储操作，源码注释说明如下：

// A Value provides an atomic load and store of a consistently typed value.

无情翻译：Value 提供任意一致性类型值的原子 load 和 store 操作。

3.1 API 作用

// Store sets the value of the Value to x.
// All calls to Store for a given Value must use values of the same concrete type.
// Store of an inconsistent type panics, as does Store(nil).
func (v *Value) Store(x interface{})

无情翻译：Store 操作把 x 存储到 v，要求所有的 Store 调用传入的 x 的类型是一致的，若存储不一致类型的值，会直接 panic。

// Load returns the value set by the most recent Store.
// It returns nil if there has been no call to Store for this Value.
func (v *Value) Load() (x interface{})

无情翻译：Load 操作会返回最近一次 Store 存储的值。如果 v 还没通过 Store 存储过东西，会返回 nil。

源码分析参考：atomic 包的使用及解析

最后

如果你有疑惑，欢迎评论，我会尽可能回复！

如果本文对你有帮助，点个赞吧，这是我坚持的动力！