go: per-loop vs per-iteration demo

Author: PegasusWang

go-note/tricks.rst

@@ -740,91 +740,93 @@ Go 如何复制map
       testShareMap()
     }
 
-循环变量与闭包问题 ⭐️
+循环变量与闭包问题 ⚠️
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 go 的循环变量是 per-loop 的而不是 per-iteration 绑定的，这个特性导致了很多隐蔽反直觉并且难以排查的bug。
 go 官方目前仍在讨论是否要改善这个问题：https://github.com/golang/go/discussions/56010 。
-举一些常见例子防止踩坑：
+
+举三个常见例子防止踩坑：
 
 .. code-block:: go
 
-    package main
+  package main
 
-    import (
-            "fmt"
-            "time"
-    )
+  import (
+      "fmt"
+      "time"
+  )
+
+  // 示例1：goroutine 直接使用闭包变量
+  func testForLoopGoroutine() {
+      data := []string{"one", "two", "three"}
+      for _, v := range data {
+          go func() {
+              fmt.Println(v) // 最终打印的都是一样的值，和期望不符
+          }()
+      }
+      // output: three three three
+  }
+
+  // 两种方式解决：1.使用一个临时变量
+  func testForLoopGoroutine1() {
+      data := []string{"one", "two", "three"}
+      for _, v := range data {
+          v := v // 使用一个临时变量 v
+          go func() {
+              fmt.Println(v)
+          }()
+      }
+      // one two three (may wrong order)
+  }
+
+  // 方法2：传给匿名goroutine参数
+  func testForLoopGoroutine2() {
+      data := []string{"one", "two", "three"}
+      for _, v := range data {
+          go func(in string) {
+              fmt.Println(in)
+          }(v)
+      }
+      // one two three (may wrong order)
+  }
 
-    // 闭包问题
-    func testClosure() {
-            data := []string{"one", "two", "three"}
-            for _, v := range data {
-                    go func() {
-                            fmt.Println(v)
-                    }()
-            }
-            time.Sleep(1 * time.Second) // not good, just for demo
-            // three three three  // 打印的都是最后一个值
-    }
+  // 示例2：对循环变量取地址
+  type MyStruct struct{ i int }
 
-    // 两种方式解决：1.使用一个块临时变量
-    func testClosure1() {
-            data := []string{"one", "two", "three"}
-            for _, v := range data {
-                    vcopy := v // 使用一个临时变量，经常可以看到 v := v 这种写法
-                    go func() {
-                            fmt.Println(vcopy)
-                    }()
-            }
-            time.Sleep(1 * time.Second) // not good, just for demo
-            // one two three (may wrong order)
-    }
+  func testForLoopPointer() {
+      values := []MyStruct{MyStruct{1}, MyStruct{2}, MyStruct{3}}
+      output := []*MyStruct{}
 
-    // 方法2：使用传给匿名goroutine参数，个人推荐使用这种方式
-    func testClosure2() {
-            data := []string{"one", "two", "three"}
-            for _, v := range data {
-                    go func(in string) {
-                            fmt.Println(in)
-                    }(v)
-            }
-            time.Sleep(1 * time.Second) // not good, just for demo
-            // one two three (may wrong order)
-    }
+      for _, v := range values {
+          // v := v // 加上这一行才能打印1，2，3
+          output = append(output, &v) // 如果不用临时变量，始终取到的是同一个地址
+      }
 
-    // 指针接收者调用场景
-    type field struct {
-            name string
-    }
+      for _, o := range output {
+          fmt.Println(o.i) // 都打印3
+      }
+  }
 
-    func (p *field) print() {
-            fmt.Println(p.name)
-    }
+  // 示例3：接收者指针
+  type field struct{ name string }
 
-    func testField() {
-            data := []field{{"one"}, {"two"}, {"three"}}
-            for _, v := range data {
-                    // v := v    // NOTE：直接这样就可以解决，
-                    // 或者使用 struct 指针。 []*field 初始化
-                    go v.print() // print three three three
-            }
-            time.Sleep(1 * time.Second)
-    }
+  func (p *field) print() { // 接收者是指针
+      fmt.Println(p.name)
+  }
 
-    // 结构体示例
-    values := []MyStruct{MyStruct{1}, MyStruct{2}, MyStruct{3}}
-    output := []*MyStruct{}
-    for _, v := range values {
-      // v := v
-      output = append(output, &v) // 不要直接引用一个循环变量的地址
-    }
-    fmt.Println("output: ", output) // 打印相同的地址
+  func testForLoopPointerReceiver() {
+      data := []field{{"one"}, {"two"}, {"three"}} // 改成 []*field 可以修复
+      for _, v := range data {
+          // v := v       // NOTE：直接这样就可以解决。或者使用 struct 指针，[]*field 初始化
+          go v.print() // print three three three
+      }
+  }
 
-总结一下：
+总结一下会出bug的常见情况：
 
-- 不要直接对循环变量取地址
-- 不要在 goroutine 中直接使用循环变量
-- 如果循环变量(非指针)调用函数是一个指针接收者，调用值需要拷贝一个临时变量再调用
+- 在 goroutine 中直接使用循环变量(示例1)
+- 循环中直接对循环变量取地址(示例2)
+- 循环变量(非指针)调用函数是一个指针接收者，调用却直接传入循环变量值(示例3)
 
 解决方式：