乐趣区

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

jiezi

一.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…

谢谢您的观看，欢送关注我的公众号。
退出移动版