go语言提供的原子操作都是非侵入式的，它们由标准库代码包sync/atomic中的众多函数代表。

　　 我们调用sync/atomic中的几个函数可以对几种简单的类型进行原子操作。这些类型包括int32,int64,uint32,uint64,uintptr,unsafe.Pointer,共6个。这些函数的原子操作共有5种：增或减，比较并交换、载入、存储和交换它们提供了不同的功能，切使用的场景也有区别。

增或减

　　 顾名思义，原子增或减即可实现对被操作值的增大或减少。因此该操作只能操作数值类型。

　　 被用于进行增或减的原子操作都是以“Add”为前缀，并后面跟针对具体类型的名称。

//方法源码
func AddUint32(addr *uint32, delta uint32) (new uint32)


增加

示例：（在原来的基础上加n）

atomic.AddUint32(&addr,n)


减

示例：(在原来的基础上加n（n为负数))

atomic.AddUint32(*addr,uint32(int32(n)))
//或
atomic.AddUint32(&addr,^uint32(-n-1))


比较并交换

　　 比较并交换----Compare And Swap 简称CAS

　　 他是假设被操作的值未曾被改变（即与旧值相等），并一旦确定这个假设的真实性就立即进行值替换

　　 如果想安全的并发一些类型的值，我们总是应该优先使用CAS

//方法源码
func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)


示例：（如果addr和old相同,就用new代替addr）

ok:=atomic.CompareAndSwapInt32(&addr,old,new)


载入

　　 如果一个写操作未完成，有一个读操作就已经发生了，这样读操作使很糟糕的。

　　 为了原子的读取某个值sync/atomic代码包同样为我们提供了一系列的函数。这些函数都以"Load"为前缀，意为载入。

//方法源码
func LoadInt32(addr *int32) (val int32)


示例

fun addValue(delta int32){
    for{
        v:=atomic.LoadInt32(&addr)
        if atomic.CompareAndSwapInt32(&v,addr,(delta+v)){
            break;
        }
    }
}


存储

　　 与读操作对应的是写入操作，sync/atomic也提供了与原子的值载入函数相对应的原子的值存储函数。这些函数的名称均以“Store”为前缀

　　 在原子的存储某个值的过程中，任何cpu都不会进行针对进行同一个值的读或写操作。如果我们把所有针对此值的写操作都改为原子操作，那么就不会出现针对此值的读操作读操作因被并发的进行而读到修改了一半的情况。

　　 原子操作总会成功，因为他不必关心被操作值的旧值是什么。

//方法源码
func StoreInt32(addr *int32, val int32)


示例

atomic.StoreInt32(被操作值的指针,新值)
atomic.StoreInt32(&value,newaddr)


交换

　　 原子交换操作，这类函数的名称都以“Swap”为前缀。

　　 与CAS不同，交换操作直接赋予新值，不管旧值。

　　 会返回旧值

//方法源码
func SwapInt32(addr *int32, new int32) (old int32)


示例

atomic.SwapInt32(被操作值的指针,新值)（返回旧值）
oldval：=atomic.StoreInt32(&value,newaddr)

 

通过sync/atomic 包的原子操作对原始类型s(int32, int64, etc.) 进行操作的时候，很容易忘记在对变量进行读取和修改的时候，使用原子操作。

而go.uber.org/atomic包通过隐藏基础类型对这些操作增加了类型安全，另外，它还包括了一个方便的atomic.Bool类型。

Bad

type foo struct {
  running int32  // 原子类型
}

func (f* foo) start() {
   //原子操作
  if atomic.SwapInt32(&f.running, 1) == 1 {
     // 已经在运行了
     return
  }
  // start the Foo
}

func (f *foo) isRunning() bool {
  return f.running == 1  // 忘记使用原子操作导致资源竞争
}

Good

type foo struct {
  running atomic.Bool //使用atomic.Bool类型
}

func (f *foo) start() {
//使用Swap(true)进行安全判断
  if f.running.Swap(true) {
     // already running…
     return
  }
  // start the Foo
}

func (f *foo) isRunning() bool {
 //使用Load()方法保证安全
  return f.running.Load()
}

 

1. Go中的原子操作
原子性：一个或多个操作在CPU的执行过程中不被中断的特性，称为原子性。这些操作对外表现成一个不可分割的整体，他们要么都执行，要么都不执行，外界不会看到他们只执行到一半的状态。
原子操作：进行过程中不能被中断的操作，原子操作由底层硬件支持，而锁则是由操作系统提供的API实现，若实现相同的功能，前者通常会更有效率
最小案例：
package main

import (
	"sync"
	"fmt"
)

var count int

func add(wg *sync.WaitGroup) {
	defer wg.Done()
	count++
}

func main() {
	wg := sync.WaitGroup{}
	wg.Add(1000)
	for i := 0; i < 1000; i++ {
		go add(&wg)
	}
	wg.Wait()
	fmt.Println(count)
}

count不会等于1000，因为count++这一步实际是三个操作：

从内存读取count
CPU更新count = count + 1
写入count到内存

因此就会出现多个goroutine读取到相同的数值，然后更新同样的数值到内存，导致最终结果比预期少
2. Go中sync/atomic包
Go语言提供的原子操作都是非入侵式的，由标准库中sync/aotomic中的众多函数代表
atomic包中支持六种类型

int32
uint32
int64
uint64
uintptr
unsafe.Pointer

对于每一种类型，提供了五类原子操作：

LoadXXX(addr): 原子性的获取*addr的值，等价于：

return *addr      


StoreXXX(addr, val): 原子性的将val的值保存到*addr，等价于：

addr = val 


AddXXX(addr, delta):

原子性的将delta的值添加到*addr并返回新值（unsafe.Pointer不支持），等价于：

*addr += delta
return *addr


SwapXXX(addr, new) old: 原子性的将new的值保存到*addr并返回旧值，等价于：

old = *addr
*addr = new
return old


CompareAndSwapXXX(addr, old, new) bool:

原子性的比较addr和old，如果相同则将new赋值给addr并返回true，等价于：

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

在这里插入图片描述

因此第一部分的案例可以修改如下，即可通过
// 修改方式1
func add(wg *sync.WaitGroup) {
	defer wg.Done()
	for {
		if atomic.CompareAndSwapInt32(&count, count, count+1) {
			break
		}
	}
}
// 修改方式2
func add(wg *sync.WaitGroup) {
	defer wg.Done()
	atomic.AddInt32(&count, 1)
}

3. 扩大原子操作的适用范围：atomic.Value
Go语言在1.4版本的时候向sync/atomic包中添加了新的类型Value，此类型相当于一个容器，被用来"原子地"存储（Store）和加载任意类型的值
type Value func(v *Value) Load() (x interface{}): 读操作，从线程安全的v中读取上一步存放的内容 func(v *Value) Store(x interface{}): 写操作，将原始的变量x存放在atomic.Value类型的v中
比如作者写文章时是22岁，写着写着就23岁了…
package main

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

func main() {
	// 此处依旧选用简单的数据类型，因为代码量少
	config := atomic.Value{}
	config.Store(22)

	wg := sync.WaitGroup{}
	wg.Add(10)
	for i := 0; i < 10; i++ {
		go func(i int) {
			defer wg.Done()
			// 在某一个goroutine中修改配置
			if i == 0 {
				config.Store(23)
			}
			// 输出中夹杂22，23
			fmt.Println(config.Load())
		}(i)
	}
	wg.Wait()
}

4. atomic.Value源码分析
atomic.Value被设计用来存储任意类型的数据，所以它内部的字段是一个interface{}类型
type Value struct {
	v interface{}
}

还有一个ifaceWords类型，作为空interface的内部表示格式，typ代表原始类型，data代表真正的值
// ifaceWords is interface{} internal representation.
type ifaceWords struct {
	typ  unsafe.Pointer
	data unsafe.Pointer
}

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

4.2 实现原子性的读取任意结构操作
func (v *Value) Load() (x interface{}) {
    // 将*Value指针类型转换为*ifaceWords指针类型
	vp := (*ifaceWords)(unsafe.Pointer(v))
	// 原子性的获取到v的类型typ的指针
	typ := LoadPointer(&vp.typ)
	// 如果没有写入或者正在写入，先返回，^uintptr(0)代表过渡状态，见下文
	if typ == nil || uintptr(typ) == ^uintptr(0) {
		return nil
	}
	// 原子性的获取到v的真正的值data的指针，然后返回
	data := LoadPointer(&vp.data)
	xp := (*ifaceWords)(unsafe.Pointer(&x))
	xp.typ = typ
	xp.data = data
	return
}

4.3 实现原子性的存储任意结构操作
在此之前有一段较为重要的代码，其中runtime_procPin方法可以将一个goroutine死死占用当前使用的P (此处参考Goroutine调度器(一)：P、M、G关系, 不发散了) 不允许其他的goroutine抢占，而runtime_procUnpin则是释放方法
// Disable/enable preemption, implemented in runtime.
func runtime_procPin()
func runtime_procUnpin()

Store方法
func (v *Value) Store(x interface{}) {
	if x == nil {
		panic("sync/atomic: store of nil value into Value")
	}
	// 将现有的值和要写入的值转换为ifaceWords类型，这样下一步就能获取到它们的原始类型和真正的值
	vp := (*ifaceWords)(unsafe.Pointer(v))
	xp := (*ifaceWords)(unsafe.Pointer(&x))
	for {
		// 获取现有的值的type
		typ := LoadPointer(&vp.typ)
		// 如果typ为nil说明这是第一次Store
		if typ == nil {
			// 如果你是第一次，就死死占住当前的processor，不允许其他goroutine再抢
			runtime_procPin()
			// 使用CAS操作，先尝试将typ设置为^uintptr(0)这个中间状态
			// 如果失败，则证明已经有别的线程抢先完成了赋值操作
			// 那它就解除抢占锁，然后重新回到 for 循环第一步
			if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(^uintptr(0))) {
				runtime_procUnpin()
				continue
			}
			// 如果设置成功，说明当前goroutine中了jackpot
			// 那么就原子性的更新对应的指针，最后解除抢占锁
			StorePointer(&vp.data, xp.data)
			StorePointer(&vp.typ, xp.typ)
			runtime_procUnpin()
			return
		}
		// 如果typ为^uintptr(0)说明第一次写入还没有完成，继续循环等待
		if uintptr(typ) == ^uintptr(0) {
			continue
		}
		// 如果要写入的类型和现有的类型不一致，则panic
		if typ != xp.typ {
			panic("sync/atomic: store of inconsistently typed value into Value")
		}
		// 更新data
		StorePointer(&vp.data, xp.data)
		return
	}
}

最后


上面都是自己整理好的！我就把资料贡献出来给有需要的人！顺便求一波关注，哈哈~各位小伙伴关注我后私信【Java】就可以免费领取哒

1. Go中的原子操作
原子性：一个或多个操作在CPU的执行过程中不被中断的特性，称为原子性。这些操作对外表现成一个不可分割的整体，他们要么都执行，要么都不执行，外界不会看到他们只执行到一半的状态。
原子操作：进行过程中不能被中断的操作，原子操作由底层硬件支持，而锁则是由操作系统提供的API实现，若实现相同的功能，前者通常会更有效率
最小案例：
package main

import (
	"sync"
	"fmt"
)

var count int

func add(wg *sync.WaitGroup) {
	defer wg.Done()
	count++
}

func main() {
	wg := sync.WaitGroup{}
	wg.Add(1000)
	for i := 0; i < 1000; i++ {
		go add(&wg)
	}
	wg.Wait()
	fmt.Println(count)
}
count不会等于1000，因为count++这一步实际是三个操作：
从内存读取count
CPU更新count = count + 1
写入count到内存
因此就会出现多个goroutine读取到相同的数值，然后更新同样的数值到内存，导致最终结果比预期少
2. Go中sync/atomic包
Go语言提供的原子操作都是非入侵式的，由标准库中sync/aotomic中的众多函数代表
atomic包中支持六种类型
int32
uint32
int64
uint64
uintptr
unsafe.Pointer
对于每一种类型，提供了五类原子操作：
LoadXXX(addr): 原子性的获取*addr的值，等价于：
return *addr      
StoreXXX(addr, val): 原子性的将val的值保存到*addr，等价于：
addr = val 
AddXXX(addr, delta): 原子性的将delta的值添加到*addr并返回新值（unsafe.Pointer不支持），等价于：
*addr += delta
return *addr
SwapXXX(addr, new) old: 原子性的将new的值保存到*addr并返回旧值，等价于：
old = *addr
*addr = new
return old
CompareAndSwapXXX(addr, old, new) bool: 原子性的比较*addr和old，如果相同则将new赋值给*addr并返回true，等价于：
if *addr == old {
    *addr = new
    return true
}
return false
因此第一部分的案例可以修改如下，即可通过
// 修改方式1
func add(wg *sync.WaitGroup) {
	defer wg.Done()
	for {
		if atomic.CompareAndSwapInt32(&count, count, count+1) {
			break
		}
	}
}
// 修改方式2
func add(wg *sync.WaitGroup) {
	defer wg.Done()
	atomic.AddInt32(&count, 1)
}
3. 扩大原子操作的适用范围：atomic.Value
Go语言在1.4版本的时候向sync/atomic包中添加了新的类型Value，此类型相当于一个容器，被用来"原子地"存储（Store）和加载任意类型的值
type Value func(v *Value) Load() (x interface{}): 读操作，从线程安全的v中读取上一步存放的内容 func(v *Value) Store(x interface{}): 写操作，将原始的变量x存放在atomic.Value类型的v中
比如作者写文章时是22岁，写着写着就23岁了..
package main

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

func main() {
	// 此处依旧选用简单的数据类型，因为代码量少
	config := atomic.Value{}
	config.Store(22)

	wg := sync.WaitGroup{}
	wg.Add(10)
	for i := 0; i < 10; i++ {
		go func(i int) {
			defer wg.Done()
			// 在某一个goroutine中修改配置
			if i == 0 {
				config.Store(23)
			}
			// 输出中夹杂22，23
			fmt.Println(config.Load())
		}(i)
	}
	wg.Wait()
}
4. atomic.Value源码分析
atomic.Value被设计用来存储任意类型的数据，所以它内部的字段是一个interface{}类型
type Value struct {
	v interface{}
}
还有一个ifaceWords类型，作为空interface的内部表示格式，typ代表原始类型，data代表真正的值
// ifaceWords is interface{} internal representation.
type ifaceWords struct {
	typ  unsafe.Pointer
	data unsafe.Pointer
}
4.1 unsafe.Pointer
Go语言并不支持直接操作内存，但是它的标准库提供一种不保证向后兼容的指针类型unsafe.Pointer， 让程序可以灵活的操作内存，它的特别之处在于：可以绕过Go语言类型系统的检查
也就是说：如果两种类型具有相同的内存结构，我们可以将unsafe.Pointer当作桥梁，让这两种类型的指针相互转换，从而实现同一份内存拥有两种解读方式
例如int类型和int32类型内部的存储结构是一致的，但是对于指针类型的转换需要这么做：
var a int32
// 获得a的*int类型指针
(*int)(unsafe.Pointer(&a))
4.2 实现原子性的读取任意结构操作
func (v *Value) Load() (x interface{}) {
    // 将*Value指针类型转换为*ifaceWords指针类型
	vp := (*ifaceWords)(unsafe.Pointer(v))
	// 原子性的获取到v的类型typ的指针
	typ := LoadPointer(&vp.typ)
	// 如果没有写入或者正在写入，先返回，^uintptr(0)代表过渡状态，见下文
	if typ == nil || uintptr(typ) == ^uintptr(0) {
		return nil
	}
	// 原子性的获取到v的真正的值data的指针，然后返回
	data := LoadPointer(&vp.data)
	xp := (*ifaceWords)(unsafe.Pointer(&x))
	xp.typ = typ
	xp.data = data
	return
}
4.3 实现原子性的存储任意结构操作
在此之前有一段较为重要的代码，其中runtime_procPin方法可以将一个goroutine死死占用当前使用的P (此处参考Goroutine调度器(一)：P、M、G关系, 不发散了) 不允许其他的goroutine抢占，而runtime_procUnpin则是释放方法
// Disable/enable preemption, implemented in runtime.
func runtime_procPin()
func runtime_procUnpin()
Store方法
func (v *Value) Store(x interface{}) {
	if x == nil {
		panic("sync/atomic: store of nil value into Value")
	}
	// 将现有的值和要写入的值转换为ifaceWords类型，这样下一步就能获取到它们的原始类型和真正的值
	vp := (*ifaceWords)(unsafe.Pointer(v))
	xp := (*ifaceWords)(unsafe.Pointer(&x))
	for {
		// 获取现有的值的type
		typ := LoadPointer(&vp.typ)
		// 如果typ为nil说明这是第一次Store
		if typ == nil {
			// 如果你是第一次，就死死占住当前的processor，不允许其他goroutine再抢
			runtime_procPin()
			// 使用CAS操作，先尝试将typ设置为^uintptr(0)这个中间状态
			// 如果失败，则证明已经有别的线程抢先完成了赋值操作
			// 那它就解除抢占锁，然后重新回到 for 循环第一步
			if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(^uintptr(0))) {
				runtime_procUnpin()
				continue
			}
			// 如果设置成功，说明当前goroutine中了jackpot
			// 那么就原子性的更新对应的指针，最后解除抢占锁
			StorePointer(&vp.data, xp.data)
			StorePointer(&vp.typ, xp.typ)
			runtime_procUnpin()
			return
		}
		// 如果typ为^uintptr(0)说明第一次写入还没有完成，继续循环等待
		if uintptr(typ) == ^uintptr(0) {
			continue
		}
		// 如果要写入的类型和现有的类型不一致，则panic
		if typ != xp.typ {
			panic("sync/atomic: store of inconsistently typed value into Value")
		}
		// 更新data
		StorePointer(&vp.data, xp.data)
		return
	}
}
最后：
上面都是自己整理好的！我就把资料贡献出来给有需要的人！顺便求一波关注。
学习我们是认真的，拿大厂offer是势在必得的。java(想了解更多点一下哦)

作者：Takagi_san
链接：https://juejin.im/post/5e2c0bbb51882526b645602b