Go并发编程：循环变量捕获问题解析

本文深入探讨了Go语言中在使用Goroutine和循环时常见的变量捕获陷阱。当Goroutine在循环内部创建时，如果闭包直接引用循环变量，它们会捕获变量的引用而非其当时的值，导致所有Goroutine最终都使用循环结束时的变量值。文章提供了详细的问题分析、正确的解决方案（通过参数传递变量副本）及跨语言对比，旨在帮助开发者避免此类并发编程错误。

问题描述

在Go语言中，当我们在循环内部启动Goroutine并让其访问循环变量时，经常会遇到一个出人意料的结果：所有Goroutine打印的都是循环变量的最终值，而不是它们在Goroutine创建时所期望的值。

考虑以下Go语言代码示例：

package main

import "fmt"

func main() {
  completed := make(chan bool, 2)
  m := map[string]string{"a": "a", "b": "b"}
  for k, v := range m {
    go func() {
      fmt.Println(k, v)
      completed <- true
    }()
  }
  <- completed
  <- completed
}

这段代码尝试遍历一个map，并为每个键值对启动一个Goroutine来打印它们。然而，实际运行结果往往是：

b b
b b

或者在某些情况下可能是 a a a a，但极少会出现 a a 和 b b 同时打印的情况。这让许多初学者感到困惑，误以为是某种奇怪的并发问题。

原因分析：闭包与变量捕获

这种行为并非Go语言特有的并发问题，而是与编程语言中“闭包”如何捕获外部变量的机制有关。在Go语言中，匿名函数（即闭包）会捕获其定义时所在作用域的变量。当这些变量在循环中被声明和更新时，闭包捕获的是变量本身的“引用”或“内存地址”，而不是该变量在特定循环迭代时的“值”。

具体到上述示例：

1. for k, v := range m 循环在每次迭代时会更新 k 和 v 这两个变量的值。
2. go func() { ... }() 启动的匿名函数形成一个闭包，它捕获了外部作用域中的 k 和 v。
3. 由于Goroutine的执行是异步的，通常情况下，当Goroutine真正开始执行 fmt.Println(k, v) 时，for 循环很可能已经完成了所有迭代，或者已经进行到后续的迭代。
4. 此时，k 和 v 变量已经包含了循环的最终值（例如，map中最后一个元素的键和值）。因此，所有捕获了 k 和 v 的Goroutine都会读取到这些最终值，导致输出重复。

这与多线程无关，即使在单线程环境中，如果存在异步执行（如JavaScript中的 setTimeout），也会出现类似的问题。例如在JavaScript中：

obj = {a: 'a', b: 'b'};
for (k in obj) {
  setTimeout(function() { console.log(k, obj[k]); }, 0);
}

这段JavaScript代码同样会打印 b b 两次，因为 setTimeout 中的回调函数在执行时，for 循环已经结束，k 变量已经固定为 'b'。

解决方案：通过参数传递变量副本

解决这个问题的关键在于确保每个Goroutine都拥有其自己独立的 k 和 v 值副本，而不是共享循环变量的引用。最常见的做法是将循环变量作为参数传递给Goroutine启动的匿名函数。

修改后的Go语言代码如下：

package main

import "fmt"

func main() {
  completed := make(chan bool, 2)
  m := map[string]string{"a": "a", "b": "b"}
  for k, v := range m {
    // 将 k 和 v 作为参数传递给匿名函数
    go func(key, value string) {
      fmt.Println(key, value)
      completed <- true
    }(k, v) // 在这里立即调用匿名函数，并传入当前迭代的 k 和 v 的值
  }
  <- completed
  <- completed
}

在这个修正后的代码中：

1. go func(key, value string) { ... }(k, v) 这一行是核心。
2. 在 go func(...) 之后紧跟着的 (k, v) 表示立即调用这个匿名函数，并将当前循环迭代中 k 和 v 的值作为参数传递给它。
3. 匿名函数的形参 key 和 value 会接收到这些值。由于 key 和 value 是匿名函数内部的局部变量，每个Goroutine都会拥有自己独立的 key 和 value 副本，它们与外部循环的 k 和 v 变量是完全独立的。
4. 因此，当Goroutine执行时，它会打印出在它创建时捕获到的正确键值对。

运行修正后的代码，你将看到预期的输出：

a a
b b

或者

b b
a a

（顺序不确定，因为Goroutine的执行顺序是非确定性的）。

注意事项与最佳实践

• go run -race 工具: Go语言提供了一个强大的数据竞争检测工具。如果你运行原始的错误代码，并使用 go run -race your_program.go 命令，它很可能会报告一个数据竞争（data race），因为多个Goroutine在读取 k 和 v 的同时，主Goroutine可能还在修改它们。这有助于发现这类潜在的问题。
• 不仅仅是 for range: 这种变量捕获问题不仅限于 for range 循环，任何在循环内部创建闭包并引用循环变量的场景都可能遇到。例如，使用传统的 for i := 0; i < N; i++ 循环时，如果闭包引用 i，也需要采取类似的参数传递方式。
• 创建局部变量副本: 除了通过参数传递，另一种常见的做法是在循环内部显式地创建循环变量的局部副本：

  for k, v := range m {
      kCopy := k // 创建 k 的局部副本
      vCopy := v // 创建 v 的局部副本
      go func() {
          fmt.Println(kCopy, vCopy)
          completed <- true
      }()
  }

  这种方式同样有效，因为它确保了Goroutine捕获的是每次迭代时 kCopy 和 vCopy 的独立引用，而不是外部循环的 k 和 v。

总结

在Go语言中，当在循环内部启动Goroutine时，理解闭包如何捕获循环变量至关重要。直接引用循环变量会导致所有Goroutine看到变量的最终值，而不是迭代时的特定值。通过将循环变量作为参数传递给Goroutine函数，或者在循环内部创建局部变量副本，可以有效地解决这个问题，确保每个Goroutine都处理其预期的独立数据。掌握这一技巧是编写健壮、可预测的Go并发程序的关键一步。