经验分享：for 循环里的 Race 竞态问题详解

发表于 2年以前 | 总阅读数：556 次

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

下面的代码取是一个for的常见场景，我简化了里面的代码，如代码所见在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 竞态。下面我将介绍出现这些问题的原因，以及解决方案，最后文章结束，我会附上最终顺利运行的代码。

# 2. Go 并发编程常见两种现象

Blocking(阻塞)：是指多个（大于或等于2 个）goroutine在执行过程中，因争夺资源而造成的一种相互等待的现象。
Race(竞态)：数据竞态是指多个（大于或等于2 个）goroutine在执行过程中，读写相同数据的情况，必须存在至少一方写。另外，如果所有 goroutine 都只是进行读操作，那将不会构成数据争用。

# 3. Go 官方自带的竞态监测器

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 最终编译出的二进制包，也可用于检测是否存在数据竞态

# 4. 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 # 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数据竞态

# 6. 修复 Data Races的4种方式

Go语言中数据同步的几种方案？大概4种方式

A、等待组(sync.WaitGroup)
B、通道channel，也就是消息机制
C、原子函数
D、互斥锁（sync.Mutex）

Go语言程序可以使用通道进行多个 goroutine 间的数据交换，但这仅仅是数据同步中的一种方法。通道内部的实现依然使用了各种锁，因此优雅代码的代价是性能。在某些轻量级的场合，原子访问（atomic包）、互斥锁（sync.Mutex）以及等待组（sync.WaitGroup）能最大程度满足需求。

# 7. 修复 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在执行++操作的时候，其他的协程都得等待。

# 8. 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 中的执行顺序是无序的，业务中做的时候需要了解。这种无序性，如果业务需要有顺序最后用线性阻塞的编程，减少用并发。

# 9. 最初的广告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
}