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 value int ) func Take() { var wg sync.WaitGroup wg.Add(3) go func() { defer wg.Done() AddValue() }() go func() { defer wg.Done() AddValue() }() go func() { defer wg.Done() AddValue() }() wg.Wait() fmt.Println(value) } func AddValue() { mutex.Lock() for i := 0; i < 1000; i++ { time.Sleep(time.Microsecond * 5) value++ } mutex.Unlock() }
Mutex经常被这样使用：
package main import ( "fmt" "sync" ) type Container struct { mu sync.Mutex counters map[string]int } func (c *Container) inc(name string) { c.mu.Lock() defer c.mu.Unlock() c.counters[name]++ } func main() { c := Container{ counters: map[string]int{"a": 0, "b": 0}, } var wg sync.WaitGroup doIncrement := func(name string, n int) { for i := 0; i < n; i++ { c.inc(name) } wg.Done() } wg.Add(3) go doIncrement("a", 10000) go doIncrement("a", 10000) go doIncrement("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 Student struct { Id int Name string } var once sync.Once func UserOnce() { once.Do(func() { var stu *Student stu = new(Student) fmt.Println(&stu) }) } func TestOnce(t *testing.T) { for i := 0; i < 5; i++ { go UserOnce() } time.Sleep(5 * time.Second) }
3.4 WaitGroup
WaitGroup等待一组goroutines完成。主goroutines调用Add来设置等待Goroutines。然后是每一个goroutine运行并在完成时调用Done。与此同时，Wait可以用来阻塞，直到所有goroutines完成。
var ( mutex sync.Mutex value int ) func Take() { var wg sync.WaitGroup wg.Add(3) go func() { defer wg.Done() AddValue() }() go func() { defer wg.Done() AddValue() }() go func() { 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 createNum int32 func createBuffer() interface{} { atomic.AddInt32(&createNum, 1) buffer := make([]byte, 1024) return buffer } func Main() { bufferPool := &sync.Pool{New: createBuffer,} workerPool := 1024 * 1024 var wg sync.WaitGroup wg.Add(workerPool) for i := 0; i < workerPool; i++ { go func(){ 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 main import ( "fmt" "sync" "sync/atomic" ) func main() { var ops uint64 var wg sync.WaitGroup for i := 0; i < 50; i++ { wg.Add(1) go func() { 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
