1 什么是并发原语？
在操作系统中，往往设计一些完成特定功能的、不可中断的过程，这些不可中断的过程称为原语。
因此，并发原语就是在编程语言设计之初以及后续的扩展过程中，专门为并发设计而开发的关键词或代码片段或一部分功能，进而能够为该语言实现并发提供更好的支持。
2 Go都有哪些并发原语？
2.1 官方并发原语
比较耳熟能详的就有goroutine、sync包下的Mutex、RWMutex、Once、WaitGroup、Cond、channel、Pool、Context、Timer、atomic等等
2.2 扩展并发原语
几乎都是不耳熟能详的，如Semaphore、SingleFlight、CyclicBarrier、ReentrantLock等等
3 官方并发原语的具体概念和用法
3.0 goroutine
请移步这篇文章：《深入浅出Go并发之协程—goroutine》
3.1 Mutex
Mutex是一种互斥锁，并且不可重入。类似于Java中的Lock对象。
var(
mutex sync.Mutex
valueint)funcTake(){var wg sync.WaitGroup
wg.Add(3)gofunc(){defer wg.Done()AddValue()}()gofunc(){defer wg.Done()AddValue()}()gofunc(){defer wg.Done()AddValue()}()
wg.Wait()
fmt.Println(value)}funcAddValue(){
mutex.Lock()for i:=0; i<1000; i++{
time.Sleep(time.Microsecond*5)
value++}
mutex.Unlock()}Mutex经常被这样使用：
package mainimport("fmt""sync")type Containerstruct{
mu sync.Mutex
countersmap[string]int}func(c*Container)inc(namestring){
c.mu.Lock()defer c.mu.Unlock()
c.counters[name]++}funcmain(){
c:= Container{
counters:map[string]int{"a":0,"b":0},}var wg sync.WaitGroup
doIncrement:=func(namestring, nint){for i:=0; i< n; i++{
c.inc(name)}
wg.Done()}
wg.Add(3)godoIncrement("a",10000)godoIncrement("a",10000)godoIncrement("b",10000)
wg.Wait()
fmt.Println(c.counters)}3.2 RWMutex
**RWMutex是一种读写互斥锁，该锁可以被任意数量的读取器或单个写入器持有。**其他用法与Mutex类似。
3.3 Once
Once是指只执行一个动作的对象。
函数调用函数f当且仅当函数调用Do时这是Once实例的第一次。换句话说，给定var once Once,如果once.Do(f)被多次调用，只有第一次调用会调用f，即使f在每次调用中有不同的值。
type Studentstruct{
Idint
Namestring}var once sync.OncefuncUserOnce(){
once.Do(func(){var stu*Student
stu=new(Student)
fmt.Println(&stu)})}funcTestOnce(t*testing.T){for i:=0; i<5; i++{goUserOnce()}
time.Sleep(5* time.Second)}3.4 WaitGroup
WaitGroup等待一组goroutines完成。主goroutines调用Add来设置等待Goroutines。然后是每一个goroutine运行并在完成时调用Done。与此同时，Wait可以用来阻塞，直到所有goroutines完成。
var(
mutex sync.Mutex
valueint)funcTake(){var wg sync.WaitGroup
wg.Add(3)gofunc(){defer wg.Done()AddValue()}()gofunc(){defer wg.Done()AddValue()}()gofunc(){defer wg.Done()AddValue()}()
wg.Wait()
fmt.Println(value)}3.5 Cond
Cond 实现了一种条件变量，可以使用多个 Reader 等待公共资源。
每个 Cond 都会关联一个 Lock ,当修改条件或者调用 Wait 方法，必须加锁，保护 Condition。 有点类似 Java 中的 Wait 和 NotifyAll。
sync.Cond 条件变量是用来协调想要共享资源的那些 goroutine, 当共享资源的状态发生变化时，可以被用来通知被互斥锁阻塞的 gorountine。
3.6 channel
3.7 Pool
sync.Pool 本质用途是增加临时对象的重用率，减少 GC 负担。一个Pool 可以被多个goroutine同时使用。
var createNumint32funccreateBuffer()interface{}{
atomic.AddInt32(&createNum,1)
buffer:=make([]byte,1024)return buffer}funcMain(){
bufferPool:=&sync.Pool{New: createBuffer,}
workerPool:=1024*1024var wg sync.WaitGroup
wg.Add(workerPool)for i:=0; i< workerPool; i++{gofunc(){defer wg.Done()
buffer:= bufferPool.Get()_= buffer.([]byte)defer bufferPool.Put(buffer)}()}
wg.Wait()
fmt.Printf(" %d buffer objects were create.\n",createNum)
time.Sleep(10* time.Second)}3.8 Context
3.9 atomic
go语言的atomic包实现的原子操作：
atomic中的类型Value，可用来**“原子的”**存储或加载任意类型的值。
func(v *Value) Load() (x interface{}): 读操作，从线程安全的v中读取上一步存放的内容func(v *Value) Store(x interface{}): 写操作，将原始的变量x存放在atomic.Value类型中
package mainimport("fmt""sync""sync/atomic")funcmain(){var opsuint64var wg sync.WaitGroupfor i:=0; i<50; i++{
wg.Add(1)gofunc(){for c:=0; c<1000; c++{
atomic.AddUint64(&ops,1)}
wg.Done()}()}
wg.Wait()
fmt.Println("ops:", ops)}4 小总结
一提到并发，不由让人想到锁的作用，没错，锁对于并发是必不可少的，即使是channel类型，底层也是基于锁的，除此，CAS的概念也越发重要，他可以解决并发程序中典型的ABA问题，因此，并发编程无非就是解决多线程竞争资源的各种问题。
Go语言的并发原语的学习当然不能止步于一篇文章，需要我们不断的在实践中学习和领悟。
参考：
https://blog.csdn.net/qq_36310758/article/details/115326176
https://www.jianshu.com/p/ed1a5c11bbb9
https://www.jb51.net/article/221684.htm
https://gobyexample-cn.github.io/
https://blog.csdn.net/weixin_38387929/article/details/119413161
https://blog.csdn.net/alwaysrun/article/details/125023283