go并发编程
一.背景知识介绍
1.进程和线程
- 进程是程序在操作系统中一次执行的过程，系统进行资源分配和调度的基本单位
- 线程是进程的一个执行实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位
- 一个进程可以创建和撤销多个线程，同一个进程中的多个线程之间可以并发执行
2.并发和并行
- 多线程程序在单核CPU上运行，就是并发
- 多线程程序在多核CPU上运行，就是并行
- 并发不是并行，并发主要是由切换时间片来实现同时运行，并行则是直接利用多核实现多线程的运行，go可以设置使用的核数，以发挥多核计算机的能力
3.协程和线程
- 协程：独立的栈空间，共享堆空间，调度由用户自己控制，本质上有点类似于用户级线程，这些用户级线程的调度也是自己实现的
- 线程，一个线程上可以跑多个协程，协程是轻量级的线程
4.goroutine
- 每个goroutine实例只有4-5KB的内存占用(可伸缩),和由于实现机制而大幅度减少的创建和销毁开销是go高并发的根本原因
- goroutine 奉行通过通信来共享内存，而不是通过共享内存来通信
二.Channel
- Go语言的并发模型是CSP，提倡通过通信来进行内存共享，而不是通过共享内存来实现通信
- goroutine是Go程序并发的实体，channel就是他们之间的连接，channel是可以让一个goroutine发送特定值到另一个goroutine的通信机制
- Go语言中的channel是一种特殊的类型，channel像是一个传送带或者队列，总是遵循FIFO先入先出的原则，保证收发数据的顺序
- 每一个Channel都有其具体的传输数据类型，也就是说声明的需要为其指定元素类型
- 声明的Channel需要make初始化之后才能使用
- 声明并初始化channel
ch := make(chan int)
1.channle的操作
channel有三种操作，接收，发送，关闭。发送和接收都使用 <- 符号
- 接收
x := <- ch // 从ch中接收值并赋值给变量x
- 发送
ch <- 10 // 把10发送到ch中
- 关闭
close(ch)
注意事项：
- 关于关闭通道，只有在需要通知接收方的goroutine，所有的数据都已经发送完毕的时候，才需要关闭通道，也就是说，关闭通道，可以告诉接收方的goroutine，所有的数据都已经发送完毕了
- 通道是可以被GC回收的，关闭通道不是必须的，不像文件那样，在结束操作后必须关闭文件
- 对一个关闭的通道，再发送数据，就会导致panic
- 对一个关闭的通道进行接收会一直获取值，直到通道为空为止
- 对一个关闭的，并且没有值的通道，进行接收操作，会得到对应类型的零值
- 关闭一个已经关闭的通道会导致panic
2.无缓冲的Channel
- 无缓冲通道，又叫做阻塞通道
- 无缓冲通道只有在有人接收值的时候才能发送值，否则就会一直阻塞住，同样的，只有在有人发送值的时候，才能接收值
func main() {
ch := make(chan int)
ch <- 10
fmt.Println("发送成功")
// fatal error: all goroutines are asleep - deadlock!
}
func recv(c chan int) {
ret := <-c
fmt.Println("接收成功", ret)
}
func main() {
ch := make(chan int)
go recv(ch) // 启用goroutine从通道接收值
ch <- 10
fmt.Println("发送成功")
}
- 使用无缓冲通道进行通信将导致发送和接收的goroutine同步化，因此，无缓冲通道也被称为同步通道
3.有缓冲的Channel
- 在通道使用make函数初始化的时候可以指定缓冲容量
ch := make(chan int, 10) // 创建一个容量为10的有缓冲区通道
- 只要通道的容量大于0，那么该通道就是有缓冲通道
- 通道的容量表示通道中能最多存放元素的数量
- 通过len函数获取当前通道内元素数量，通过cap函数获取通道的容量
4.单向channel
- 限制通道在函数中只能发送或者接收
- chan <- int是一个只能发送的通道，可以发送但是不能接收；
- <-chan int是一个只能接收的通道，可以接收但是不能发送。
- 在函数传参以及任何赋值操作中，将双向通道转为单向通道是可以的，但反过来不行
func counter(out chan<- int) {
for i := 0; i < 100; i++ {
out <- i
}
close(out)
}
func squarer(out chan<- int, in <-chan int) {
for i := range in {
out <- i * i
}
close(out)
}
func printer(in <-chan int) {
for i := range in {
fmt.Println(i)
}
}
func main() {
ch1 := make(chan int)
ch2 := make(chan int)
go counter(ch1)
go squarer(ch2, ch1)
printer(ch2)
}
5.优雅的从通道循环取值
- 通过通道发送有限的数据时，可以通过close函数关闭通道来告知接收该通道值的goroutine停止等待
- 当通道关闭时，再往该通道发送值会导致panic，并且从该通道接收到值，全部接收完了之后再接收的话，会接收到类型零值
- 那我们应该如何判断通道被关闭了呢？有下面两种方法可供参考
func main() {
ch1 := make(chan int)
ch2 := make(chan int)
// 开启goroutine将0~100的数发送到ch1中
go func() {
for i := 0; i < 100; i++ {
ch1 <- i
}
close(ch1)
}()
// 开启goroutine从ch1中接收值，并将该值的平方发送到ch2中
go func() {
for {
i, ok := <-ch1 // 通道关闭后再取值ok=false
if !ok {
break
}
ch2 <- i * i
}
close(ch2)
}()
// 在主goroutine中从ch2中接收值打印
for i := range ch2 { // 通道关闭后会退出for range循环
fmt.Println(i)
}
}
6.channel异常情况总结
三.select多路复用
- 在某些场景下，我们需要从多个通道接收数据，通道在接收数据时，如果没有数据可以接收得阻塞住，等待数据过来，为了应对这种场景，GO内置了select关键字，可以同时响应多个通道的操作
- go select的思想来源于网络IO模型中的select，本质上也是IO多路复用，只不过这里的IO是基于channel而不是基于网络
- select的使用类似switch，有一系列case和default，每个case对应一个通道的接收或发送过程
select {
case <-chan1:
// 如果chan1成功读到数据，则进行该case处理语句
case chan2 <- 1:
// 如果成功向chan2写入数据，则进行该case处理语句
default:
// 如果上面都没有成功，则进入default处理流程
}
- select会一直等待，直到某个case的通信操作完成时，就会执行case分支对应的语句
- select可以同时监听多个channel，直到其中一个channel 就绪，如果多个channel同时就绪，则随机选择一个执行
- select可以用来判断管道是否已满，比如仅有一个case和default，该case是往管道写，当管道满了之后，该case会失败，因仅有一个case，所以会走default，那就可以在default中通知该通道已满
package main
import (
"fmt"
"time"
)
// 判断管道有没有存满
func main() {
// 创建管道
output1 := make(chan string, 10)
// 子协程写数据
go write(output1)
// 取数据
for s := range output1 {
fmt.Println("res:", s)
time.Sleep(time.Second)
}
}
func write(ch chan string) {
for {
select {
// 写数据
case ch <- "hello":
fmt.Println("write hello")
default: // 因为通道满了，往执行不了写数据了，就会走default
fmt.Println("channel full")
}
time.Sleep(time.Millisecond * 500)
}
}
四.goroutine池
- 本质是生产者消费者模型
- 可以有效的控制goroutine数量，防止暴涨
- 需求：
- 计算一个数字的各个数位之和，例如数字123，结果是1+2+3=6
- 随机生成数字进行计算
package main
import (
"fmt"
"math/rand"
)
type Job struct {
// id
Id int
// 需要计算的随机数
RandNum int
}
type Result struct {
// 这里必须传对象实例
job *Job
// 求和
sum int
}
func main() {
// 需要2个管道
// 1.job管道
jobChan := make(chan *Job, 128)
// 2.结果管道
resultChan := make(chan *Result, 128)
// 3.创建工作池
createPool(64, jobChan, resultChan)
// 4.开个打印的协程
go func(resultChan chan *Result) {
// 遍历结果管道打印
for result := range resultChan {
fmt.Printf("job id:%v randnum:%v result:%d\n", result.job.Id,
result.job.RandNum, result.sum)
}
}(resultChan)
var id int
// 循环创建job，输入到管道
for {
id++
// 生成随机数
r_num := rand.Int()
job := &Job{
Id: id,
RandNum: r_num,
}
jobChan <- job
}
}
// 创建工作池
// 参数1：开几个协程
func createPool(num int, jobChan chan *Job, resultChan chan *Result) {
// 根据开协程个数，去跑运行
for i := 0; i < num; i++ {
go func(jobChan chan *Job, resultChan chan *Result) {
// 执行运算
// 遍历job管道所有数据，进行相加
for job := range jobChan {
// 随机数接过来
r_num := job.RandNum
// 随机数每一位相加
// 定义返回值
var sum int
for r_num != 0 {
tmp := r_num % 10
sum += tmp
r_num /= 10
}
// 想要的结果是Result
r := &Result{
job: job,
sum: sum,
}
//运算结果扔到管道
resultChan <- r
}
}(jobChan, resultChan)
}
}
五.并发安全和锁
- 当多个goroutine操作同一个临界区的资源时，可能会有数据竞态问题，导致非预期结果
样例如下，我们启动两个goroutine去累加x的值，但这两个goroutine访问x时会存在数据竞争
var x int64
var wg sync.WaitGroup
func add() {
for i := 0; i < 5000; i++ {
x = x + 1
}
wg.Done()
}
func main() {
wg.Add(2)
go add()
go add()
wg.Wait()
fmt.Println(x)
}
1.互斥锁
- 互斥锁是一种常用的控制共享资源访问的方法
- Go语言中使用sync包的Mutex类型来实现互斥锁
- 使用互斥锁可以保证同一时间有且只有一个goroutine进入临界区，其他goroutine则在等待锁
- 当互斥锁释放后，等待的goroutine才可以获取锁进入临界区
- 多个goroutine同时等待一个锁时，唤醒的策略是随机的
var x int64
var wg sync.WaitGroup
var lock sync.Mutex
func add() {
for i := 0; i < 5000; i++ {
lock.Lock() // 加锁
x = x + 1
lock.Unlock() // 解锁
}
wg.Done()
}
func main() {
wg.Add(2)
go add()
go add()
wg.Wait()
fmt.Println(x)
}
2.读写锁
- 很多场景下是读多写少的，当我们并发去读取一个资源不涉及资源修改时，完全没有必要使用互斥锁，因为互斥锁是完全互斥的
- 读多写少的情况下，使用读写锁是一个更好的选择
- Go语言中使用sync包的RWMutex来实现读写锁
- 读写锁分为两种：读锁和写锁
- 当一个goroutine获取读锁之后，其他的goroutine如果是获取读锁则会获得读锁，如果是获取写锁就会等待
- 当一个goroutine获取写锁之后，其他的goroutine无论是获取读锁还是获取写锁，都会等待
- 读写锁非常适合读多写少的场景，如果读和写差别不大，则读写锁的优势就发挥不出来
样例如下：
var (
x int64
wg sync.WaitGroup
lock sync.Mutex
rwlock sync.RWMutex
)
func write() {
// lock.Lock() // 加互斥锁
rwlock.Lock() // 加写锁
x = x + 1
time.Sleep(10 * time.Millisecond) // 假设读操作耗时10毫秒
rwlock.Unlock() // 解写锁
// lock.Unlock() // 解互斥锁
wg.Done()
}
func read() {
// lock.Lock() // 加互斥锁
rwlock.RLock() // 加读锁
time.Sleep(time.Millisecond) // 假设读操作耗时1毫秒
rwlock.RUnlock() // 解读锁
// lock.Unlock() // 解互斥锁
wg.Done()
}
func main() {
start := time.Now()
for i := 0; i < 10; i++ {
wg.Add(1)
go write()
}
for i := 0; i < 1000; i++ {
wg.Add(1)
go read()
}
wg.Wait()
end := time.Now()
fmt.Println(end.Sub(start))
}
3.sync.Map
- Go语言中内置的map并不是并发安全的
样例如下：
var m = make(map[string]int)
func get(key string) int {
return m[key]
}
func set(key string, value int) {
m[key] = value
}
func main() {
wg := sync.WaitGroup{}
for i := 0; i < 20; i++ {
wg.Add(1)
go func(n int) {
key := strconv.Itoa(n)
set(key, n)
fmt.Printf("k=:%v,v:=%v\n", key, get(key))
wg.Done()
}(i)
}
wg.Wait()
// fatal error: concurrent map writes
}
- Go语言的sync包中提供了一个开箱即用的并发安全版Map,sync.Map，开箱即用表示不用像内置的Map一样使用make函数初始化就能用，同时sync.Map内置了诸如Store，Load，LoadOrStore，Delete，Range等操作方法。
var m = sync.Map{}
func main() {
wg := sync.WaitGroup{}
for i := 0; i < 20; i++ {
wg.Add(1)
go func(n int) {
key := strconv.Itoa(n)
m.Store(key, n)
value, _ := m.Load(key)
fmt.Printf("k=:%v,v:=%v\n", key, value)
wg.Done()
}(i)
}
wg.Wait()
}
六.并发同步
- Go语言中使用sync包的WaitGroup来实现并发任务的同步
1.sync.WaitGroup
sync.WaitGroup有以下三种方法：
- (wg * WaitGroup) Add(delta int) : 计数器 + delta
- (wg *WaitGroup) Done() : 计数器-1
- (wg *WaitGroup) Wait() : 阻塞知道计数器变为0
sync.WaitGroup内部维护着一个计数器，计数器的值可以增加和减少，例如当我们启动了N个并发任务时，就将计数器增加N，每个任务通过调用Done方法将计数器减1，通过调用Wait()来等待并发任务执行完，当计数器的值为0时间，表示所有并发任务都已经完成
var wg sync.WaitGroup
func hello() {
defer wg.Done()
fmt.Println("Hello Goroutine!")
}
func main() {
wg.Add(1)
go hello() // 启动另外一个goroutine去执行hello函数
fmt.Println("main goroutine done!")
wg.Wait()
}
2.sync.Once
- 很多场景下，我们需要确保某些操作在高并发时只执行一次，例如只加载一次配置文件
- Go语言中的sync包提供了一个针对只执行一次场景的解决方案-sync.Once
- sync.Once只有一个Do方法，Do(f func())
样例如下：
- 延迟一个开销很大的初始化操作到真正用到它的时候再执行
var icons map[string]image.Image
var loadIconsOnce sync.Once
func loadIcons() {
icons = map[string]image.Image{
"left": loadIcon("left.png"),
"up": loadIcon("up.png"),
"right": loadIcon("right.png"),
"down": loadIcon("down.png"),
}
}
// Icon 是并发安全的
func Icon(name string) image.Image {
loadIconsOnce.Do(loadIcons)
return icons[name]
}
sync.Once内部包含一个互斥锁和一个布尔值，互斥锁保证布尔值和数据的安全，而布尔值用来记录初始化是否完成，这样设计就能保证初始化操作的时候是并发安全的，并且初始化操作也不会执行多次
七.原子操作
- 代码中加锁操作因为设计到内核态的上下文切换，耗时比较高，代价也大
- 针对基本数据类型我们可以使用原子操作来保证并发安全
- Go语言中原子操作由内置的标准库sync/atomic提供
样例如下：
- 比较互斥锁和原子操作的性能
var x int64
var l sync.Mutex
var wg sync.WaitGroup
// 普通版加函数
func add() {
// x = x + 1
x++ // 等价于上面的操作
wg.Done()
}
// 互斥锁版加函数
func mutexAdd() {
l.Lock()
x++
l.Unlock()
wg.Done()
}
// 原子操作版加函数
func atomicAdd() {
atomic.AddInt64(&x, 1)
wg.Done()
}
func main() {
start := time.Now()
for i := 0; i < 10000; i++ {
wg.Add(1)
// go add() // 普通版add函数 不是并发安全的
// go mutexAdd() // 加锁版add函数 是并发安全的，但是加锁性能开销大
go atomicAdd() // 原子操作版add函数 是并发安全，性能优于加锁版
}
wg.Wait()
end := time.Now()
fmt.Println(x)
fmt.Println(end.Sub(start))
}
- atomic包提供了底层的原子级内存操作，对于同步算法的实现很有帮助，但是除了某些特殊的底层应用，使用通道或者sync包实现同步更好！
八.总结
Go语言的并发模型是CSP，提倡通过通信来进行内存共享，而不是通过共享内存来实现通信