在这里插入图片描述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对象。
代码语言：go复制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经常被这样使用：
代码语言：go复制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在每次调用中有不同的值。
代码语言：go复制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完成。
代码语言：go复制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
请移步这篇文章：《深入浅出Go语言通道chan类型》
3.7 Pool
sync.Pool 本质用途是增加临时对象的重用率，减少 GC 负担。一个Pool 可以被多个goroutine同时使用。
代码语言：go复制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
请移步这篇文章：《一文搞懂Go语言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
https://blog.csdn.net/alwaysrun/article/details/125023283
我正在参与2024腾讯技术创作特训营第五期有奖征文，快来和我瓜分大奖！
