工作中查看项目代码,发现会存在使用 GO 语言做并发的时候出现各种各样的异常情况,有的输出结果和自己期望和设计的不一致,有的是程序直接阻塞住,更有甚者直接是程序 crash 掉。
实际上,出现上述的情况,还是因为我们对于 GO 语言的并发模型和涉及的 GO 语言基础不够扎实,误解了语言的用法。
那么,对于 GO 语言的并发模式,我们一起来梳理一波。 GO 语言常见的并发模式有这些:
- 创建模式
- 退出模式
- 管道模式
- 超时模式和取消模式
在 GO 语言里面,咱们使用使用并发,自然离不开使用 GO 语言的协程 goroutine,通道 channel 和 多路复用 select,接下来就来看看各种模式都是如何去搭配使用这三个关键原语的
创建模式
使用过通道和协程的朋友对于创建模式肯定不会模式,这是一个非常常用的方式,也是一个非常简单的使用方式:
- 主协程中调用 help 函数,返回一个通道 ch 变量
- 通道 ch 用于主协程和 子协程之间的通信,其中通道的数据类型完全可以自行定义
type XXX struct{...} func help(fn func()) chan XXX { ch := make(chan XXX) // 开启一个协程 go func(){ // 此处的协程可以控制和外部的 主协程 通过 ch 来进行通信,达到一定逻辑便可以执行自己的 fn 函数 fn() ch <- XXX }() } func main(){ ch := help(func(){ fmt.Println("这是GO 语言 并发模式之 创建模式") }) <- ch }
退出模式
程序的退出我们应该也不会陌生,对于一些常驻的服务,如果是要退出程序,自然是不能直接就断掉,此时会有一些连接和业务并没有关闭,直接关闭程序会导致业务异常,例如在关闭过程中最后一个 http 请求没有正常响应等等等
此时,就需要做优雅关闭了,对于协程 goroutine 退出有 3 种模式
- 分离模式
- join 模式
- notify-and-wait 模式
分离模式
此处的分离模式,分离这个术语实际上是线程中的术语,pthread detached
分离模式可以理解为,咱们创建的协程 goroutine,直接分离,创建子协程的父协程不用关心子协程是如何退出的,子协程的生命周期主要与它执行的主函数有关,咱们 return 之后,子协程也就结束了
对于这类分离模式的协程,咱们需要关注两类,一种是一次性的任务,咱们 go 出来后,执行简单任务完毕后直接退出,一种是常驻程序,需要优雅退出,处理一些垃圾回收的事情
例如这样:
- 主程序中设置一个通道变量 ch ,类型为 os.Signal
- 然后主程序就开始各种创建协程执行自己的各种业务
- 直到程序收到了 syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT 任意一个信号的时候,则会开始进行垃圾回收等清理工作,执行完毕后,程序再进行退出
func main(){ ch := make(chan os.Signal) signal.Notify(c, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT) // ... // go 程序执行其他业务 // ... for i := range ch { switch i { case syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT: // 做一些清理工作 os.Exit(0) } } }
join 模式
看到这个关键字,是不是也似曾相识,和线程貌似很像,例如 线程中 父线程可以通过 pthread_join 来等待子线程结束,并且还可以获取子线程的结束状态
GO 语言中等待子协程退出并且获取子协程的退出状态,咱们就可以使用通道 channel 的方式来进行处理
例子1
等待一个子协程退出,并获取退出状态
- 主协程中调用 help 方法得到一个 ch 通道变量,主协程阻塞着读 ch
- help 中开辟一个子协程去执行传入的 fn 回调函数,并传参为 ok bool
- 实际 fn 函数判断传参 ok 是否是 true,若不是则返回具体的错误信息,若是 true 则返回 nil
func help(f func(bool) error, ok bool) <-chan error { ch := make(chan error) go func() { ch <- f(ok) }() return ch } func fn(ok bool) error { if !ok { return errors.New("not ok ... ") } return nil } func main() { ch := help(fn, true) fmt.Println("help 111") err := <-ch fmt.Println("help 111 done ", err) ch = help(fn, false) fmt.Println("help 222") err = <-ch fmt.Println("help 222 done ", err) }
看上如上程序,我们就可以知道,第一次调用 help(fn , true)
,主协程等待子协程退出的时候,会得到一个错误信息,为 not ok ...
, 第二次调用 help(fn , false)
的时候,返回的 err 是一个 nil
通过上述这种方式,主协程不仅可以轻易的等待一个子协程退出,还可以获取到子协程退出的状态
那么,主协程如果是等待多个协程退出呢?需要如何处理?
例子2
主协程等待多个协程退出咱们就需要使用到 GO 中的 sync.WaitGroup
- 使用 help 函数,传入回调函数,参数1 bool,参数2 int ,其中参数 2 表示开辟子协程的个数,返回值为一个无缓冲的 channel 变量,数据类型是 struct{}
- 使用 var wg sync.WaitGroup ,开辟子协程的时候记录一次 wg.Add(1),当子协程退出时 ,记录退出 wg.Done()
- help 中再另起一个协程 wg.Wait() 等待所有子协程退出,并将 ch 变量写入值
- 主协程阻塞读取 ch 变量的值,待所有子协程都退出之后,help 中写入到 ch 中的数据,主协程就能马上收到 ch 中的数据,并退出程序
func help(f func(bool)error, ok bool, num int)chan struct{}{ ch := make(chan struct{}) var wg sync.WaitGroup for i:=0; i<num; i++ { wg.Add(1) go func(){ f(ok) fmt.Println(" f done ") wg.Done() }() } go func(){ // 等待所有子协程退出 wg.Wait() ch <- struct{}{} }() return ch } func fn(ok bool) error{ time.Sleep(time.Second * 1) if !ok{ return errors.New("not ok ... ") } return nil } func main(){ ch := help(fn , true) fmt.Println("help 111") <- ch fmt.Println("help 111 done ",err) }
notify-and-wait 模式
可以看到上述模式,都是主协程等待一个子协程,或者多个子协程结束后,主协程再进行退出,或者处理完垃圾回收后退出
那么如果主协程要主动通知子协程退出,我们应该要如何处理呢?
同样的问题,如果主协程自己退出了,而没有通知其他子协程退出,这是会导致业务数据异常或者丢失的,那么此刻我们就可以使用到 notify-and-wait 模式 来进行处理
我们就直接来写一个主协程通知并等待多个子协程退出的 demo:
- 主协程调用 help 函数,得到一个 quit chan struct{} 类型的通道变量,主协程阻塞读取 quit 的值
- help 函数根据传入的参数 num 来创建 num 个子协程,并且使用 sync.WaitGroup 来控制
- 当主协程在 quit 通道中写入数据时,主动通知所有子协程退出
- help 中的另外一个协程读取到 quit 通道中的数据,便 close 掉 j 通道,触发所有的子协程读取 j 通道值的时候,得到的 ok 为 false,进而所有子协程退出
- wg.Wait() 等待所有子协程退出后,再在 quit 中写入数据
- 主协程此时从 quit 中读取到数据,则知道所有子协程全部退出,自己的主协程即刻退出
func fn(){ // 模拟在处理业务 time.Sleep(time.Second * 1) } func help(num int, f func()) chan struct{}{ quit := make(chan struct{}) j := make(chan int) var wg sync.WaitGroup // 创建子协程处理业务 for i:=0;i<num;i++{ wg.Add(1) go func(){ defer wg.Done() _,ok:=<-j if !ok{ fmt.Println("exit child goroutine .") return } // 子协程 正常执行业务 f() }() } go func(){ <-quit close(j) // 等待子协程全部退出 wg.Wait() quit <- struct{}{} }() return quit } func main(){ quit := help(10, fn) // 模拟主程序处理在处理其他事项 // ... time.Sleep(time.Second * 10) quit <- struct{}{} // 此处等待所有子程序退出 select{ case <- quit: fmt.Println(" programs exit. ") } }
上述程序执行结果如下,可以看到 help 函数创建了 10 个子协程,主协程主动通知子协程全部退出,退出的时候也是 10 个子协程退出了,主协程才退出
上述程序,如果某一个子协程出现了问题,导致子协程不能完全退出,也就是说某些子协程在 f 函数中阻塞住了,那么这个时候主协程岂不是一直无法退出???
那么此时,在主协程通知子协程退出的时候,我们加上一个超时时间,表达意思为,超过某个时间,如果子协程还没有全部退出完毕,那么主协程仍然主动关闭程序,可以这样写:
设定一个定时器, 3 秒后会触发,即可以从 t.C 中读取到数据
t := time.NewTimer(time.Second * 3) defer t.Stop() // 此处等待所有子程序退出 select{ case <-t.C: fmt.Println("timeout programs exit. ") case <- quit: fmt.Println(" 111 programs exit. ") }
管道模式
说到管理,或许大家对 linux 里面的管道更加熟悉吧,例如使用 linux 命令找到文件中的 golang 这个字符串
cat xxx.txt |grep "golang"
那么对于 GO 语言并发模式中的管道模式也是类似的效果,我们就可以用这个管道模式来过滤数据
例如我们可以设计这样一个程序,兄弟们可以动起手来写一写,评论区见哦:
- 整个程序总共使用 2 个通道
- help 函数中传输数据量 50 ,逻辑计算能够被 5 整除的数据写到第一个通道 ch1 中
- 另一个协程阻塞读取 ch1 中的内容,并将取出的数据乘以 3 ,将结果写入到 ch2 中
- 主协程就阻塞读取 ch2 的内容,读取到内容后,挨个打印出来
管道模式有两种模式,扇出模式 和 扇入模式,这个比较好理解
- 扇出模式:多种类型的数据从同一个通道 channel 中读取数据,直到通道关闭
- 扇入模式:输入的时候有多个通道channel,程序将所有的通道内数据汇聚,统一输入到另外一个通道channel A 里面,另外一个程序则从这个通道channel A 中读取数据,直到这个通道A关闭为止
超时模式和取消模式化
超时模式
上述例子中有专门说到如何去使用他,实际上我们还可以这样用:
select{ case <- time.Afer(time.Second * 2): fmt.Println("timeout programs exit. ") case <- quit: fmt.Println(" 111 programs exit. ") }
取消模式
则是使用了 GO 语言的 context 包中的提供了上下文机制,可以在协程 goroutine 之间传递 deadline,取消等信号
我们使用的时候例如可以这样:
- 使用 context.WithCancel 创建一个可以被取消的上下文,启动一个协程 在 3 秒后关闭上下文
- 使用 for 循环模拟处理业务,默认会走 select 的 default 分支
- 3 秒后 走到 select 的 ctx.Done(),则进入到了取消模式,程序退出
ctx, cancelFunc := context.WithCancel(context.Background()) go func() { time.Sleep(time.Second * 3) cancelFunc() }() for { select { case <-ctx.Done(): fmt.Println("program exit .") return default: fmt.Println("I'm still here.") time.Sleep(time.Second) } }
总的来说,今天分享了 GO 语言中常见的几种并发模式:创建模式,退出模式,管道模式,超时模式和取消模式,更多的,还是要我们要思考其原理和应用起来,学习他们才能更加的有效
以上就是Go语言中的并发模式你了解了吗的详细内容,更多关于go并发模式的资料请关注好代码网其它相关文章!