关于go:go并发编程for循环中go协程常见问题总结

72次阅读

共计 7086 个字符,预计需要花费 18 分钟才能阅读完成。

一.for 循环中 go 协程常见问题

上面的代码取自于是七猫广告竞价场景,我简化了外面的代码,如代码所见在 for 循环外面应用了 goroutine。

package main

import ("fmt")

type ad struct {id int}
func main() {
   var sum int
   var ads []ad
   adMap := make(map[int]ad, 0)
   for i := 0; i < 5; i++ {go func() {ads = append(ads, ad{i})
         adMap[i] = ad{i}
         sum += i
      }()}
   fmt.Println(sum)        //2
   fmt.Println(ads)        // [{2} {2} {4} {4}]
   fmt.Println(len(ads))   //4
   fmt.Println(adMap)      // map[2:{2} 3:{3} 4:{4}]
   fmt.Println(len(adMap)) //3
}

下面的代码中, 咱们共申明了 3 个变量 sum、ads、adMap,而后在 for 循环外面,进行写入赋值。最初咱们再输入他们的值和长度,
后果发现每一个都谬误。

  1. sum 值 正确的值应该是 0+1+2+3+4 = 10,而代码输入的值为 2
  2. ads 值 正确的值应该是[{0} {1} {2} {3} {4}],而代码输入的值为 [{2} {2} {4} {4}]
  3. ads 长度 正确应该为 5,而代码输入 4
  4. adMap 值 正确的值应该是 map[0:{0} 1:{1} 2:{2} 3:{3} 4:{4}],而代码输入的值为 map[2:{2} 3:{3} 4:{4}]
  5. adMap 长度 正确的应该为 5,而代码输入 3

到底是什么起因导致了,这样的谬误后果呢,答案是 Race 竞态。
上面我将介绍呈现这些问题的起因,以及解决方案,最初文章完结,我会附上最终顺利运行的代码。

二.go 并发编程常见两种景象

  • Blocking(阻塞):是指多个(大于或等于 2 个)goroutine 在执行过程中,因抢夺资源而造成的一种互相期待的景象。
  • Race(竞态):数据竞态是指多个(大于或等于 2 个)goroutine 在执行过程中,读写雷同数据的状况,必须存在至多一方写。另外,如果所有 goroutine 都只是进行读操作,那将不会形成数据争用。

三.golang 官网自带的竞态监测器

Go 语言运行时和工具链配备了一个粗劣并易于应用的动态分析工具:竞态检测器 (race detector)。
只须要把 -race 命令行参数加到 go build、go run、go test 命令里边即可应用该性能。竞态检测器会钻研工夫流,找到那些有问题的案例。这个工具会输入一份报告,包含变量的标识以及读写 goroutine 过后的调用栈,通常状况下这些信息足以定位问题了。

go run -race main.go
go build -race main.go
go test -race a_test.go
go install -race main.go

备注:

  • race detector 只能找出运行时的数据竞态,所以未执行代码的数据竞态无奈被检测出。测试用例很难笼罩全所有逻辑代码,在事实工作负载状况下,运行用 -race 参数编译出的二进制文件,能够找出更多的数据竞态问题。
  • go build -race 最终编译出的二进制包,也可用于检测是否存在数据竞态

四.race 呈现起因解说

因为原理都一样,这里我以最简略的一读一写的代码进行剖析。
备注: 次要是本人想简化画流程图。

package main
import "fmt"
func main() {
   i := 0

   go func() {i = 5 // 写 i}()

   fmt.Println(i) // 读 i
}

这里,咱们申明了一个 int 类型的 i 变量,并且在这里,咱们开了两个程序。

  1. 第 6 - 8 行,咱们新建一个 go 协程设置 i = 5
  2. 在 10 行,主协程读取 i
    此时打印进去的 i,有可能是 0(默认值)或者 5。
    这就是 data race 数据竞态,数据值取决于哪个协程先执行。

Data race 数据竞态当 先读,输入 0

Data race 数据竞态当 先写,输入 5

五. 检测 Data race 数据竞态

咱们执行的时候加上 -race 参数

go run -race ./main.go

输入后果如下

0
==================
WARNING: DATA RACE
Write at 0x00c00009c008 by goroutine 6:
  main.main.func1()
      /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/s/main.go:7 +0x44

Previous read at 0x00c00009c008 by main goroutine:
  main.main()
      /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/s/main.go:10 +0xba

Goroutine 6 (running) created at:
  main.main()
      /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/s/main.go:6 +0xb0
==================
Found 1 data race(s)

执行 go run -race 后 第二行,输入 0,阐明了 main 协程先执行了,执行第 10 行的时候,go 协程还没有写入。

  1. 第 3 - 7 行通知咱们新建的 goroutine,在写物理地址 0x00c00009c008 变量的时候,存在 DATA RACE
  2. 第 8 -10 行通知咱们 main goroutine 先读取了物理地址 0x00c00009c008 的变量
  3. 第 12-14 行通知咱们创立了一个新的 goroutine
  4. 第 16 行总结发现了一处 data race 数据竞态

六. 修复 Data Races 的 4 种形式

Go 语言中数据同步的几种计划?大略 4 种形式

  • A、期待组(sync.WaitGroup)
  • B、通道 channel,也就是音讯机制
  • C、原子函数
  • D、互斥锁(sync.Mutex)

Go 语言程序能够应用通道进行多个 goroutine 间的数据交换,但这仅仅是数据同步中的一种办法。
通道外部的实现仍然应用了各种锁,因而优雅代码的代价是性能。
在某些轻量级的场合,原子拜访(atomic 包)、互斥锁(sync.Mutex)以及期待组(sync.WaitGroup)能最大水平满足需要。

七. 修复 Data Races 竞态 4 种代码样例

1. 应用 WaitGroup 来 Blocking(阻塞)

官网文档对 WaitGroup 的形容是:一个 WaitGroup 对象能够期待一组协程完结。应用办法是:

  1. main 协程通过调用 wg.Add(delta int) 设置 worker 协程的个数,而后创立 worker 协程;
  2. worker 协程执行完结当前,都要调用 wg.Done();
  3. main 协程调用 wg.Wait() 且被 block,直到所有 worker 协程全副执行完结后返回。
package main
import "fmt"
import "sync"
func main() {
   i := 0
   // 初始化 1 个 waitGroup variable
   var wg sync.WaitGroup
   // Add(1) 减少一个须要期待的 waitGroup 工作
   wg.Add(1)
   go func() {
      i = 5 // 写 i = 5
      // wg.Done 示意,waitGroup 实现一个工作
      wg.Done()}()
   // wg.Wait 阻塞程序执行 直到 wg.Done 都实现了 wg.Add 的对应工作数
   wg.Wait()
   fmt.Println(i) // 读 i
}

执行流程如下

直到写 i=5 的 goroutine 写入实现,waitGroup 始终阻塞过程。

2. 应用 Channel 来 Blocking(阻塞)

channel 无缓冲通道的特点是,发送的数据须要被读取后,发送才会实现,它阻塞场景:

  1. channel 中无数据时候输入,会始终阻塞读数据,直到有数据写入。
  2. channel 中有数据的时候,会始终阻塞,晓得输入数据,变成空 channel。
package main
import "fmt"
func main() {
   i := 0
   // 创立
   done := make(chan int)
   defer close(done)
   go func() {
      i = 5 // 写 i = 5
      // 写入 channel
      done <- 1
   }()
   // 阻塞,直到有值可能从 channel 输入
   <-done
   fmt.Println(i) // 读 i
}

执行流程如下

直到写 i=5 的 goroutine 写入实现,channel 始终阻塞读。

3. 应用 Channel 作为返回值

代替应用 channel 来阻塞程序,咱们能够应用 channel 作为返回值。这样当咱们 push 一个值进行的时候,他会主动阻塞,直到这个值被读取。

package main
func main() {
   i := 0
   // 创立
   result := make(chan int)
   go func() {
      // 写入 5 到 channel
      result <- 5
   }()
   i = <-result
   println(i) // 读 i
}

执行流程如下

这里应用 channel 来保留值, 通过 <-result 输入实现阻塞,直到有值写入到 channel。

4. 应用 Mutex 锁

上面的代码,最初的 sum,本次输入每次都不一样

package main

import (
   "fmt"
   "sync"
)

func main() {
   sum := 0
   wg := sync.WaitGroup{}
   for i := 0; i < 1000; i++ {wg.Add(1)
      go func() {
         sum++
         wg.Done()}()}
   wg.Wait()
   fmt.Println(sum) //975
}

输入

975

起因排查:
咱们应用竞态排查一下

go run -race  ./main.go

输入如下:

==================
WARNING: DATA RACE
Read at 0x00c00013c018 by goroutine 8:
  main.main.func1()
      /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/sa/main.go:14 +0x39

Previous write at 0x00c00013c018 by goroutine 7:
  main.main.func1()
      /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/sa/main.go:14 +0x4b

Goroutine 8 (running) created at:
  main.main()
      /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/sa/main.go:13 +0x84

Goroutine 7 (finished) created at:
  main.main()
      /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/sa/main.go:13 +0x84
==================
975
Found 25 data race(s)
exit status 66

第 3 行:阐明有一个 goroutine 8,在读 sum
第 7 行:阐明有一个 goroutine 7,在写 sum 作为一个公共变量,同时被读写,产生了竞态。
解决方案:
sync.Mutex 是 Go 规范库中罕用的一个排外锁。当一个 goroutine 取得了这个锁的拥有权后,其它申请锁的 goroutine 就会阻塞在 Lock 办法的调用上,直到锁被开释。

此时咱们用 mutex,避免 sum 被同时读写,代码革新如下。

package main

import (
   "fmt"
   "sync"
)

func main() {
   sum := 0
   wg := sync.WaitGroup{}
   m := sync.Mutex{}
   for i := 0; i < 1000; i++ {wg.Add(1)
      go func() {m.Lock()
         sum++
         m.Unlock()
         wg.Done()}()}
   wg.Wait()
   fmt.Println(sum)
}

输入:

100

咱们在 第 15-17 行,给 sum 加了锁,此时只有有一个协程 goroutine 在执行 ++ 操作的时候,其余的协程都得期待。

八.for 循环中 go 协程作用域

1. 咱们先看下最简略的 for 如下

package main

import "fmt"

func main() {
   for i := 0; i < 2; i++ {go func() {fmt.Println(i)
      }()}
}

下面的代码,最初没有输入。咱们的冀望输入 0 1 的欲望落空了,什么起因?
程序执行工夫图

如上图,咱们发现在下面的程序有 2 种状况

  1. 当主过程完结,goroutine2,goroutine3 都还没执行完,则没有输入。
  2. 状况 2,如下图 goroutine2 执行完,输入了 1 !!!! 留神不是 0!!!!

从下面学到的解决竞态 4 中计划,咱们用 waitGroup 阻塞主过程,改良代码如下:

package main

import (
   "fmt"
   "sync"
)

func main() {wg := sync.WaitGroup{}
   for i := 0; i < 2; i++ {wg.Add(1)
      go func() {fmt.Println(i)
         wg.Done()}()}
   wg.Wait()}

输入如下:

2
2

终于两个 goroutine 都执行,但后果和咱们其余的 0,1 齐全不一样。为啥?

当 goroutine2,goroutine3 打印的时候,main goroutine 曾经将 i 变成 2 了,而在整个 for 内,i 是同一个变量。此时就打印变成了 2 了。

2.for 循环中 go 协程作用域

咱们看上面的示例代码

package main

import (
   "fmt"
   "time"
)

func main() {
    // for 循环作用域开始 
   for i := 0; i < 2; i++ {go func() {fmt.Println(i)
      }()}//for 循环作用域完结
   time.Sleep(time.Second)
}

输入后果如下:

2
2

这是因为 i 的作用域的起因,咱们能够把 for 循环的代码重写如下:

func main() {
   // for 循环作用域开始 
   var i int
   for i = 0; i < 2; i++ {go func() {fmt.Println(i)
      }()}//for 循环作用域完结
   time.Sleep(time.Second)
}

这两种写法是等价,能够看进去 i 的作用域 为第 2 行到第 7 行,括号完结。此时就会呈现下面的都是 2 的状况。
那么咱们只有把传进 goroutine 的变量范畴变成 goroutine 之内就能解决这个问题了。

2.1 办法一 goroutine 加参数

func main() {
   var i int
   for i = 0; i < 2; i++ {go func(j int) {fmt.Println(j)
      }(i)
   }
   time.Sleep(time.Second)
}

输入如下:

0
1

2.2 办法二放大变量范畴到 goroutine 的范畴内

func main() {
   var i int
   for i = 0; i < 2; i++ {
      j := i
      go func() {fmt.Println(j)
      }()}
   time.Sleep(time.Second)
}

3. 变量范畴革新代码革新如下

此时如果是这样,那么就要稳固 goroutine 的值,让它只在 goroutine 内,那么设置一个 goroutine 内变量就能够了。代码革新如下。

package main

import (
   "fmt"
   "sync"
)

func main() {wg := sync.WaitGroup{}
   for i := 0; i < 2; i++ {wg.Add(1)
      go func(j int) {fmt.Println(j)
         wg.Done()}(i)
   }
   wg.Wait()}

输入

1
0

执行如下,此次是 goroutine3 先打印了,而后才是 goroutine2

阐明 for goroutine 中的执行程序是 无序的,业务中做的时候须要理解。这种 无序性 ,如果业务须要有程序
最初用线性阻塞的编程,缩小用并发。

九. 最后的广告 for 代码,如何革新

  1. 主 goroutine 阻塞期待所有的 goroutine 实现。咱们用 WaitGroup
  2. goroutine 传参,把 for 循环的失效的变量,变成 goroutine 内失效的变量,放弃值的始终性
  3. 对于公共变量 sum,ads,adMap 同时被读写的问题,咱们用 sync.Mutex 上锁。这样只有一个协程能够同时扭转他们的值
package main

import (
   "fmt"
   "sync"
)

type ad struct {id int}

func main() {wg := sync.WaitGroup{}
   lock := sync.Mutex{}
   var sum int
   var ads []ad
   adMap := make(map[int]ad, 0)
   for i := 0; i < 5; i++ {wg.Add(1)
      go func(j int) {lock.Lock()
         defer lock.Unlock()
         sum += j
         ads = append(ads, ad{j})
         adMap[j] = ad{j}
         wg.Done()}(i)
   }
   wg.Wait()
   fmt.Println(sum)        // 10
   fmt.Println(ads)        // [{4} {2} {3} {0} {1}] 留神这里是无序的
   fmt.Println(len(ads))   // 5
   fmt.Println(adMap)      // map[0:{0} 1:{1} 2:{2} 3:{3} 4:{4}]
   fmt.Println(len(adMap)) // 5
}

参考:

https://www.sohamkamani.com/g…

谢谢您的观看,欢送关注我的公众号。

正文完
 0