一.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
}输出
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种情况
- 当主进程结束，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
12.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...
谢谢您的观看，欢迎关注我的公众号。
