Go语言并发编程：goroutine、channel、select、sync、原子操作

2022-10-27 23:33 作者:苦茶今天断更了吗 0人读过 | 我要投稿

Go语言并发编程：goroutine、channel、select、sync、原子操作

并发并行、goroutine、channel的内容看之前的笔记

Go语言中的操作系统线程和goroutine的关系：

①一个操作系统线程对应用户态多个goroutine。

②go程序可以同时使用多个操作系统线程。

③goroutine和OS线程是多对多的关系，即m:n。

Runtime包

runtime.Gosched( )：让出CPU时间片，重新等待安排任务。

runtime.Goexit( )：退出当前协程。

runtime.GOMAXPROCS：

Go运行时的调度器使用GOMAXPROCS参数来确定需要使用多少个OS线程来同时执行Go代码。默认值是机器上的CPU核心数。（GOMAXPROCS是m:n调度中的n）。

Go语言中可以通过runtime.GOMAXPROCS( )函数设置当前程序并发时占用的CPU逻辑核心数。

Go1.5版本之前，默认使用的是单核心执行。Go1.5版本之后，默认使用全部的CPU逻辑核心数。

可以通过将任务分配到不同的CPU逻辑核心上实现并行的效果，举个例子：

无缓冲的通道（阻塞的通道、同步通道）：

为什么会出现deadlock错误呢？

因为使用ch := make(chan int)创建的是无缓冲的通道，无缓冲的通道必须有接收才能发送。

上面的代码会阻塞在ch <- 10这一行代码形成死锁，那如何解决这个问题呢？

一种方法是启用一个goroutine去接收值，例如：

无缓冲通道上的发送操作会阻塞，直到另一个goroutine在该通道上执行接收操作，这时值才能发送成功，两个goroutine将继续执行。相反，如果接收操作先执行，接收方的goroutine将阻塞，直到另一个goroutine在该通道上发送一个值。

使用无缓冲通道进行通信将导致发送和接收的goroutine同步化。因此，无缓冲通道也被称为同步通道。

有缓冲的通道：

可以在使用make函数初始化通道的时候为其指定通道的容量，例如：

只要通道的容量大于零，那么该通道就是有缓冲的通道，通道的容量表示通道中能存放元素的数量。

可以使用内置的len函数获取通道内元素的数量，使用cap函数获取通道的容量。

close()：

可以通过内置的close()函数关闭channel（如果你的管道不往里存值或者取值的时候，一定记得关闭管道）

当通过通道发送有限的数据时，我们可以通过close函数关闭通道来告知从该通道接收值的goroutine停止等待。当通道被关闭时，往该通道发送值会引发panic，从该通道里接收的值一直都是类型零值。那如何判断一个通道是否被关闭了呢？

单向通道：

有的时候我们会将通道作为参数在多个任务函数间传递，很多时候我们在不同的任务函数中使用通道都会对其进行限制，比如限制通道在函数中只能发送或只能接收。

Go语言中提供了单向通道来处理这种情况。例如，我们把上面的例子改造如下：

chan<- int是一个只能发送（只写）的通道，可以发送但是不能接收；

<-chan int是一个只能接收（只读）的通道，可以接收但是不能发送；

worker pool（goroutine池）：

本质上是生产者消费者模型

可以有效控制goroutine数量，防止暴涨

需求：

计算一个数字的各个位数之和，例如数字123，结果为1+2+3=6

随机生成数字进行计算

定时器：

Timer：时间到了，执行只执行1次

Ticker：时间到了，多次执行。

Select：

select多路复用：

在某些场景下我们需要同时从多个通道接收数据。通道在接收数据时，如果没有数据可以接收将会发生阻塞。

这种方式虽然可以实现从多个通道接收值的需求，但是运行性能会差很多。为了应对这种场景，Go内置了select关键字，可以同时响应多个通道的操作。

select的使用类似于switch语句，它有一系列case分支和一个默认的分支。每个case会对应一个通道的通信（接收或发送）过程。select会一直等待，直到某个case的通信操作完成时，就会执行case分支对应的语句。具体格式如下：

select可以同时监听一个或多个channel，直到其中一个channel ready：

如果多个channel同时ready，则随机选择一个执行：

可以用于判断管道是否存满：

并发安全和锁：

有时候在Go代码中可能会存在多个goroutine同时操作一个资源（临界区），这种情况会发生竞态问题（数据竞态）。

上面的代码中我们开启了两个goroutine去累加变量x的值，这两个goroutine在访问和修改x变量的时候就会存在数据竞争，导致最后的结果与期待的不符。

互斥锁：

互斥锁是一种常用的控制共享资源访问的方法，它能够保证同时只有一个goroutine可以访问共享资源。Go语言中使用sync包的Mutex类型来实现互斥锁。使用互斥锁来修复上面代码的问题：

使用互斥锁能够保证同一时间有且只有一个goroutine进入临界区，其他的goroutine则在等待锁；当互斥锁释放后，等待的goroutine才可以获取锁进入临界区，多个goroutine同时等待一个锁时，唤醒的策略是随机的。

读写互斥锁：

互斥锁是完全互斥的，但是有很多实际的场景下是读多写少的，当我们并发的去读取一个资源不涉及资源修改的时候是没有必要加锁的，这种场景下使用读写锁是更好的一种选择。 读写锁在Go语言中使用sync包中的RWMutex类型。

读写锁分为两种：读锁和写锁。当一个goroutine获取读锁之后，其他的goroutine如果是获取读锁会继续获得锁，如果是获取写锁就会等待；当一个goroutine获取写锁之后，其他的goroutine无论是获取读锁还是写锁都会等待。

Sync：

sync.WaitGroup：

在代码中生硬的使用time.Sleep肯定是不合适的，Go语言中可以使用sync.WaitGroup来实现并发任务的同步。

sync.WaitGroup是一个结构体，传递的时候要传递指针。

sync.WaitGroup有以下几个方法：

sync.WaitGroup内部维护着一个计数器，计数器的值可以增加和减少。例如当我们启动了N 个并发任务时，就将计数器值增加N。每个任务完成时通过调用Done()方法将计数器减1。通过调用Wait()来等待并发任务执行完，当计数器值为0时，表示所有并发任务已经完成。

sync.Once：

在编程的很多场景下我们需要确保某些操作在高并发的场景下只执行一次，例如只加载一次配置文件、只关闭一次通道等。

sync.Once只有一个Do方法，其签名：func (o *Once) Do(f func()) {}

注意：如果要执行的函数f需要传递参数就需要搭配闭包来使用。

加载配置文件示例：

延迟一个开销很大的初始化操作到真正用到它的时候再执行是一个很好的实践。因为预先初始化一个变量（比如在init函数中完成初始化）会增加程序的启动耗时，而且有可能实际执行过程中这个变量没有用上，那么这个初始化操作就不是必须要做的。看一个例子：

多个goroutine并发调用Icon函数时不是并发安全的，现代的编译器和CPU可能会在保证每个goroutine都满足串行一致的基础上自由地重排访问内存的顺序。loadIcons函数可能会被重排为以下结果：

在这种情况下就会出现即使判断了icons不是nil也不意味着变量初始化完成了。考虑到这种情况，我们能想到的办法就是添加互斥锁，保证初始化icons的时候不会被其他的goroutine操作，但是这样做又会引发性能问题。使用sync.Once改造的示例代码如下：

sync.Once其实内部包含一个互斥锁和一个布尔值，互斥锁保证布尔值和数据的安全，而布尔值用来记录初始化是否完成。这样设计就能保证初始化操作的时候是并发安全的，并且初始化操作也不会被执行多次。

sync.Map：Go语言中内置的map不是并发安全的。

上面的代码开启少量几个goroutine的时候可能没什么问题，当并发多了之后执行上面的代码就会报fatal error: concurrent map writes错误。

像这种场景下就需要为map加锁来保证并发的安全性了，Go语言的sync包中提供了一个开箱即用的并发安全版map–sync.Map。开箱即用表示不用像内置的map一样使用make函数初始化就能直接使用。同时sync.Map内置了诸如Store、Load、LoadOrStore、Delete、Range等操作方法。