vlambda博客
学习文章列表

源码分析golang协程闭包数据陷阱

0x1

我们在写协程程序的时候,经常会碰到一个场景就是我们要分发执行任务给不同的goroutine(简称gor),然后再把各个gor的处理结果汇总起来,这个时候就要注意gor的数据污染问题,我们可以通过闭包来防范各个gor之间的数据污染

0x2

下面的一个gor之间数据互相污染的范例

 
   
   
 
  1. func main() {

  2. setMem := make(map[int]int)

  3. wg := sync.WaitGroup{}

  4. lk := sync.RWMutex{}


  5. for i := 0; i < 10; i++ { // 1

  6. wg.Add(1)


  7. go func(wg *sync.WaitGroup) { // 2

  8. fmt.Println("i ---- ", i)

  9. defer wg.Done()

  10. lk.Lock()

  11. setMem[i] = i * 2

  12. lk.Unlock()

  13. }(&wg)


  14. }


  15. wg.Wait()

  16. fmt.Println("setMem 长度为 ----------", len(setMem))

  17. fmt.Println("setMem done ... ")

  18. }

这个的运行结果并非如我们所想,汇总了10个 gor的处理结果到 setMem 这个map中去

 
   
   
 
  1. setMem 长度为 ---------- 1

  2. setMem done ...

原因分析

注释1 因为main gor 和 go func 是同时在运行的, 所以main在赋值给 i 的同时, 2 接收到 i 的值并没有锁定 i , 而是接收到最新的for循环的值

注释2 没有一个安全的内存区域储存传给当前 gor 的 i 值,所以造成数据污染

0x3

用闭包的原理去解决这个问题

 
   
   
 
  1. func setM(wg *sync.WaitGroup, lk *sync.RWMutex, setMemx *map[int]int, i int) {

  2. defer wg.Done()

  3. fmt.Println("i ---- ", i)

  4. (*setMemx)[i] = i * 2

  5. }


  6. func main() {

  7. setMemx := make(map[int]int)

  8. wg := sync.WaitGroup{}

  9. lk := sync.RWMutex{}


  10. for i := 0; i < 10; i++ { // 1

  11. wg.Add(1)

  12. setM(&wg, &lk, &setMemx, i) // 2

  13. }


  14. wg.Wait()

  15. fmt.Println("setMem 长度为 ----------", len(setMemx))

  16. fmt.Println("setMem done ... ")

  17. }

运行结果

 
   
   
 
  1. setMen 长度为 ---------- 10

  2. setMem done ...

注释1 1 处依然是通过循环赋予 i 值注释2 2通过声明独立的func,来进行内存数据作用域锁定,闭包的原理,防止数据污染

所以运行的结果如我们所想