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

一.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循环外面，进行写入赋值。最初咱们再输入他们的值和长度，
后果发现每一个都谬误。

sum值正确的值应该是 0+1+2+3+4 = 10，而代码输入的值为 2
ads值正确的值应该是[{0} {1} {2} {3} {4}]，而代码输入的值为 [{2} {2} {4} {4}]
ads长度正确应该为5，而代码输入4
adMap值正确的值应该是 map[0:{0} 1:{1} 2:{2} 3:{3} 4:{4}]，而代码输入的值为 map[2:{2} 3:{3} 4:{4}]
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变量，并且在这里，咱们开了两个程序。

第6-8行，咱们新建一个go协程设置 i = 5
在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协程还没有写入。

第3-7行通知咱们新建的goroutine，在写物理地址0x00c00009c008变量的时候，存在DATA RACE
第8-10行通知咱们main goroutine 先读取了物理地址0x00c00009c008的变量
第12-14行通知咱们创立了一个新的goroutine
第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 对象能够期待一组协程完结。应用办法是：

main协程通过调用 wg.Add(delta int) 设置worker协程的个数，而后创立worker协程；
worker协程执行完结当前，都要调用 wg.Done()；
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无缓冲通道的特点是，发送的数据须要被读取后，发送才会实现，它阻塞场景：

channel中无数据时候输入，会始终阻塞读数据，直到有数据写入。
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
}

输入

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

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)
}

输入：

咱们在第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种状况

当主过程完结，goroutine2，goroutine3 都还没执行完，则没有输入。
状况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代码，如何革新

主goroutine阻塞期待所有的goroutine实现。咱们用WaitGroup
goroutine传参，把for循环的失效的变量，变成goroutine内失效的变量，放弃值的始终性
对于公共变量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…

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

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

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

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

四.race呈现起因解说

五.检测Data race数据竞态

六.修复 Data Races的4种形式

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

1.应用WaitGroup来Blocking(阻塞)

2.应用Channel来Blocking(阻塞)

3.应用Channel作为返回值

4.应用Mutex锁

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

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

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

2.1 办法一goroutine加参数

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

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

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

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

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

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

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

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

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

四.race呈现起因解说

五.检测Data race数据竞态

六.修复 Data Races的4种形式

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

1.应用WaitGroup来Blocking(阻塞)

2.应用Channel来Blocking(阻塞)

3.应用Channel作为返回值

4.应用Mutex锁

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

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

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

2.1 办法一goroutine加参数

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

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

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

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

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复