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

头像
海生
     上海
    阅读 9 分钟
    3

    图片
    更方便的在微信公众号阅读文章可以关注公众号：海生的go花园
    image.png

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

    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...
    https://www.modb.pro/db/72705
    https://colobu.com/2018/12/18...
    https://time.geekbang.org/col...

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

    image.png

    go
    海生
    104 声望32 粉丝

    与黑夜里，追求那一抹萤火。

    « 上一篇
    mysql 正则匹配搜索 rlike
    下一篇 »
    mysql常用字段规范整理

    引用和评论

    推荐阅读
    头像
    Linux Crontab 定时任务，时间格式

    海生阅读 802

    头像
    Go 语言-计算密集型服务 性能优化

    Jesse赞 4阅读 5.2k

    头像
    IO 密集型服务 耗时优化

    Jesse赞 4阅读 4.4k

    头像
    Go 语言 JSON 与 Cache 库 调研与选型

    Jesse赞 2阅读 4.1k

    头像
    Go 程序如何实现优雅退出？来看看 K8s 是怎么做的——上篇

    江湖十年赞 5阅读 715

    头像
    Go 语言-内存泄漏排查两例

    Jesse赞 1阅读 1.9k

    头像
    Golang GC 从原理到优化

    Jesse阅读 5.8k

    0 条评论
    得票最新