一.for循环中go协程常见问题
上面的代码取自于是七猫广告竞价场景，我简化了外面的代码，如代码所见在for循环外面应用了goroutine。
package mainimport ( "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.gogo build -race main.gogo test -race a_test.gogo install -race main.go备注：
- race detector 只能找出运行时的数据竞态，所以未执行代码的数据竞态无奈被检测出。测试用例很难笼罩全所有逻辑代码，在事实工作负载状况下，运行用 -race 参数编译出的二进制文件，能够找出更多的数据竞态问题。
- go build -race 最终编译出的二进制包，也可用于检测是否存在数据竞态
四.race呈现起因解说
因为原理都一样，这里我以最简略的一读一写的代码进行剖析。
备注:次要是本人想简化画流程图。
package mainimport "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 RACEWrite at 0x00c00009c008 by goroutine 6: main.main.func1() /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/s/main.go:7 +0x44Previous read at 0x00c00009c008 by main goroutine: main.main() /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/s/main.go:10 +0xbaGoroutine 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 mainimport "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 mainimport "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 mainfunc 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 mainimport ( "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 RACERead at 0x00c00013c018 by goroutine 8: main.main.func1() /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/sa/main.go:14 +0x39Previous write at 0x00c00013c018 by goroutine 7: main.main.func1() /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/sa/main.go:14 +0x4bGoroutine 8 (running) created at: main.main() /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/sa/main.go:13 +0x84Goroutine 7 (finished) created at: main.main() /Users/zhanghaisheng/study/dataStructure/gosourcecode/main/sa/main.go:13 +0x84==================975Found 25 data race(s)exit status 66第3行：阐明有一个goroutine 8 ，在读 sum
第7行：阐明有一个goroutine 7，在写sum作为一个公共变量，同时被读写，产生了竞态。
解决方案：
sync.Mutex是Go规范库中罕用的一个排外锁。当一个 goroutine 取得了这个锁的拥有权后， 其它申请锁的 goroutine 就会阻塞在 Lock 办法的调用上，直到锁被开释。
此时咱们用mutex，避免sum被同时读写，代码革新如下。
package mainimport ( "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 mainimport "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 mainimport ( "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()}输入如下：
22终于两个goroutine都执行，但后果和咱们其余的0,1 齐全不一样。为啥？
当goroutine2，goroutine3 打印的时候，main goroutine 曾经将 i变成2了，而在整个for内，i是同一个变量。此时就打印变成了2了。
2.for循环中go协程作用域
咱们看上面的示例代码
package mainimport ( "fmt" "time")func main() { // for 循环作用域开始 for i := 0; i < 2; i++ { go func() { fmt.Println(i) }() }//for 循环作用域完结 time.Sleep(time.Second)}输入后果如下：
22这是因为 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)}输入如下：
012.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 mainimport ( "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()}输入
10执行如下，此次是 goroutine3 先打印了，而后才是 goroutine2
阐明 for goroutine 中的执行程序是 无序的 ，业务中做的时候须要理解。这种无序性，如果业务须要有程序
最初用线性阻塞的编程，缩小用并发。
九.最后的广告for代码，如何革新
- 主goroutine阻塞期待所有的goroutine实现。咱们用WaitGroup
- goroutine传参，把for循环的失效的变量，变成goroutine内失效的变量，放弃值的始终性
- 对于公共变量sum，ads，adMap同时被读写的问题，咱们用sync.Mutex上锁。这样只有一个协程能够同时扭转他们的值
package mainimport ( "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...