Golang最为让人熟知的并发模型当属CSP并发模型，也就是由goroutine和channel构成的[GMP并发模型](https://i6448038.github.io/2017/12/04/golang-concurrency-principle/)，具体内容不在赘述了，可以翻回之前的文章查看。在这里，要讲讲Golang的其他并发方式。
Golang不仅可以使用CSP并发模式，还可以使用传统的共享数据的并发模式。
# 临界区(critical section)
这是传统语言比较常用的的方式，即加锁。加锁使其线程同步，每次只允许一个goroutine进入某个代码块，此代码块区域称之为"*临界区(critical section)*”。
Golang为*临界区(critical section)*提供的是互斥锁的包和条件变量的包。
## 互斥锁
就是通常使用的锁，用来让线程串行用的。Golang提供了互斥锁``sync.Mutex``和读写互斥锁 ``sync.RWMutex``，用法极其简单：
```
var s sync.Mutex
s.Lock()
// 这里的代码就是串行了，吼吼吼。。。
s.Unlock()
```
Lock和Unlock
### ``sync.Mutex``和``sync.RWMutex``的区别
没啥大的区别，只不过``sync.RWMutex``更加细腻，可以将“读操作”和“写操作”区别对待。
``sync.RWMutex``中的Lock和unLock针对写操作
```
var s sync.RWMutex
s.Lock()
// 上写锁了，吼吼
s.Unlock()
```
``sync.RWMutex``中的RLock和RUnLock针对读操作
```
var s sync.RWMutex
s.RLock()
// 上读锁了，吼吼..
s.RUnlock()
```
读写锁有以下规则：
+ 写锁被锁定，（再试图进行）读锁和写锁都阻塞
+ 读锁被锁定，（再试图进行）写锁阻塞，（再试图进行）读锁不阻塞
即：多个写操作不能同时进行，写操作和读操作也不能同时进行，多个读操作可以同时进行
### 注意事项：
+ 不要重复锁定互斥锁；因为代码写起来麻烦，容易出错，万一死锁(deadlock)了就废了。Go语言运行时系统自己抛出的panic都属于致命错误，都是无法恢复的，调用``recover``函数对它们起不到任何作用。一旦产生死锁，程序必然崩溃。
+ 锁定和解锁一定要成对出现，如果怕忘记解锁，最好是使用``defer``语句来解锁；但是，一定不要对未锁定的或者已经锁定的互斥锁解锁，因为会触发``panic``，而且此``panic``和死锁一样，属于致命错误，程序肯定崩溃
+ ``sync.Mutex``是个结构体，尽量不要其当做参数，在多个函数直接传播。因为没啥意义，Golang的参数都是副本，多个副本之间都是相互独立的。
## 条件变量Cond
互斥锁是用来锁住资源，“创造”临界区的。而条件变量Cond可以认为是用来自行调度线程(在此即为groutine)的，当某个状态时，阻塞等待，当状态改变时，唤醒。
Cond的使用，离不开互斥锁，即离不开``sync.Mutex``和``sync.RWMutex``。
Cond初始化都需要有个互斥锁。（ps:哪怕初始化不需要，就应用场景而言，也得需要个互斥锁）
``Cond``提供Wait、Signal、Broadcast 三种方法。
Wait表示线程(groutine)阻塞等待；
Signal表示唤醒等待的groutine；
Broadcast表示唤醒等待的所有groutine;
初始化：
```
cond := sync.NewCond(&sync.Mutex{})
```
在其中一个groutine中:
```
cond.L.Lock()
for status == 0 {
cond.Wait()
}
//状态改变，goroutine被唤醒后，干点啥。。。
cond.L.Unlock()
```
以上算是模板
在另外一个groutine中:
```
cond.L.Lock()
status = 1
cond.Signal() // 或者使用cond.Broadcast()来唤醒以上groutine中沉睡的groutine
cond.L.Unlock()
```
# 原子操作(atomicity)
原子操作是硬件芯片级别的支持，所以可以保证绝对的线程安全。而且执行效率比其他方式要高出好几个数量级。
Go语言的原子操作当然也是基于CPU和操作系统的，Go语言提供的原子操作的包是``sync/atomic``，此包提供了加(Add)、CAS(交换并比较 compare and swap)、成对出现的存储(store)和加载(load)以及交换(swap)。
此包提供的大多数函数针对的数据类型也非常的单一：只有整型！使用方式十分的简单，看着函数直接调用就好。
```
var a int32
a = 1
a = atomic.AddInt32(&a, 2) //此处是原子操作，就这么简单，吼吼
```
在此特别强调一下CAS，CAS对应的函数前缀是“CompareAndSwap”，含义和用法正如英文翻译：比较并交换。在进行CAS操作的时候，函数会先判断被操作变量的当前值是否与我们预期的旧值相等，如果相等，它就把新值赋给该变量，并返回true，反之，就忽略此操作，并返回false。
可能是Golang提供的原子操作的数据类型实在是有限，Go又补充了一个结构体``atomic.Value``，此结构体相当于一个小容器，可以提供原子操作的存储``store``和提取``load``
```
var atomicVal atomic.Value
str := "hello"
atomicVal.Store(str) //此处是原子操作哦
newStr := atomicVal.Load() //此处是原子操作哦
```
# 其他
为了能更好的调度goroutine，Go提供了``sync.WaitGroup``、``sync.Once``还有``context``
## ``sync.WaitGroup``
``sync.WaitGroup``的作用就是在多goroutine并发程序中，让主goroutine等待所有goroutine执行结束。（直接查看代码注释）
``sync.WaitGroup``提供了三个函数``Add``、``Done``和``Wait``三者用法如下：
+ Add 写在主goroutine中，参数为将要运行的goroutine的数量
+ Done 写在各个非主goroutine中，表示运行结束
+ Wait 写在主goroutine中，block主goroutine，等待所有其他goroutine运行结束
```
var wait sync.WaitGroup
wait.Add(2) //必须是运行的goroutine的数量
go func() {
//TODO 一顿小操作
defer wait.Done() // done函数用在goroutine中，表示goroutine操作结束
}()
go func() {
//TODO 一顿小操作
defer wait.Done() // done函数用在goroutine中，表示goroutine操作结束
}()
wait.Wait() // block住了，直到所有goroutine都结束
```
### 注意
``sync.WaitGroup``中有一个计数器，记录的是需要等待的goroutine的数量，默认值是0，可以通过Add方法来增加或者减少值，但是切记，千万不能让计数器的值小于零，会触发panic！
``sync.WaitGroup``调用Wait方法的时候，``sync.WaitGroup``中计数器的值一定要为0。因此Add中的值一定要等于非主goroutine的数量！
且不要把Add和Wait方法放到不同的goroutine中执行！
## ``sync.Once``
真真正正的只执行一次。
``sync.Once``只要一个方法：``Do``，里面就一个参数:``func``。多说无益，复制下面代码，猜猜执行结果就知道了。
```
package main
import (
"fmt"
"sync"
)
func main() {
var once sync.Once
onceBody := func() {
fmt.Println("Only once")
}
done := make(chan bool)
for i := 0; i < 10; i++ {
go func() {
once.Do(onceBody)
done <- true
}()
}
for i := 0; i < 10; i++ {
<-done
}
}
```
执行结果
```
Only once
```
没错，只有一行。真只执行了一次。
## context
context可以用来实现一对多的goroutine协作。这个包的应用场景主要是在API中。字面意思也很直接，上下文。当一个请求来时，会产生一个goroutine，但是这个goroutine往往要衍生出许多额外的goroutine去处理操作，例如链接database、请求rpc请求。。等等，这些衍生的goroutine和主goroutine有很多公用数据的，例如同一个请求生命周期、用户认证信息、token等，当这个请求超时或者被取消的时候，这里所有的goroutine都应该结束。context就可以帮助我们达到这个效果。
很显然，主goroutine和衍生的所有子goroutine之间形成了一颗树结构。我们的context可以从根节点遍布整棵树，当然，是线程安全的。
线程之间的基本是这样的：
```
func DoSomething(ctx context.Context, arg Arg) error {
// ... use ctx ...
}
```
有两个根context:background和todo；这两个根都是contenxt空的，没有值的。两者也没啥太本质的区别，Background是最常用的，作为Context这个树结构的最顶层的Context，它不能被取消。当不知道用啥context的时候就可以用TODO。
根生成子节点有以下方法：
```
//生成可撤销的Context (手动撤销)
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
//生成可定时撤销的Context (定时撤销)
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
//也是生成可定时撤销的Context (定时撤销)
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
//不可撤销的Context,可以存一个kv的值
func WithValue(parent Context, key, val interface{}) Context
```
### 可撤销的Context
以下是每个方法的调用方式(全都来自godoc，可粘贴复用)：
可撤销的``func WithCancel(parent Context) (ctx Context, cancel CancelFunc)``
```
gen := func(ctx context.Context) <-chan int {
dst := make(chan int)
n := 1
go func() {
for {
select {
case <-ctx.Done(): //只有撤销函数被调用后，才会触发
return
case dst <- n:
n++
}
}
}()
return dst
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel() //调用返回的cancel方法来让 context声明周期结束
for n := range gen(ctx) {
fmt.Println(n)
if n == 5 {
break
}
}
```
要想结束所有线程，就调用``ctx, cancel := context.WithCancel(context.Background())``函数返回的cancel函数即可，当撤销函数被调用之后，对应的Context值会先关闭它内部的接收通道，也就是它的Done方法返回的通道。
``WithDeadline``和``WithTimeout``用法基本类似，而且WithTimeout函数内部调用了WithDeadline函数。两者唯一区别是WithTimeout表示从现在开始xxx超时，而WithDeadline的时间可以是之前的时间：意思是说WithTimeout表示从现在开始， xxx时间后超时。而WithDeadline表示xx时间点，结束！这个时间点可以是昨天，时间点不收任何限制。
以下是godoc给出的列子：
``WithDeadline``
```
package main
import (
"context"
"fmt"
"time"
)
func main() {
d := time.Now().Add(50 * time.Millisecond)
ctx, cancel := context.WithDeadline(context.Background(), d)
// Even though ctx will be expired, it is good practice to call its
// cancelation function in any case. Failure to do so may keep the
// context and its parent alive longer than necessary.
defer cancel() //时间超时会自动调用
select {
case <-time.After(1 * time.Second):
fmt.Println("overslept")
case <-ctx.Done():
fmt.Println(ctx.Err())
}
}
```
输出：
```
context deadline exceeded
```
``WithTimeout``
```
package main
import (
"context"
"fmt"
"time"
)
func main() {
// Pass a context with a timeout to tell a blocking function that it
// should abandon its work after the timeout elapses.
ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
defer cancel() //时间超时会自动调用
select {
case <-time.After(1 * time.Second):
fmt.Println("overslept")
case <-ctx.Done():
fmt.Println(ctx.Err()) // prints "context deadline exceeded"
}
}
```
输出：
```
context deadline exceeded
```
### 不可撤销的context，传递值
``WithValue``可以用来在传递值的，值的存取是以KV的形式来进行的。直接上例子
```
type favContextKey string
f := func(ctx context.Context, k favContextKey) {
if v := ctx.Value(k); v != nil {
fmt.Println("found value:", v)
return
}
fmt.Println("key not found:", k)
}
k := favContextKey("language")
k1 := favContextKey("Chinese")
ctx := context.WithValue(context.Background(), k, "Go")
ctx1 := context.WithValue(ctx, k1, "Go1")
f(ctx1, k1)
f(ctx1, k)
```
输出：
```
found value: Go1
found value: Go
```
#### 更多精彩内容，请关注我的微信公众号 ``互联网技术窝`` 或者加微信共同探讨交流：
今日阅读排行
一周阅读排行