在 for 每个循环中使用 go 例程时，由 func 文字捕获的 go vet 范围变量

Question

我不太确定“func 文字”是什么，因此这个错误让我有点困惑。我想我看到了这个问题——我从一个新的 go 例程中引用一个范围值变量，因此该值可能随时改变，而不是我们所期望的。解决问题的最佳方法是什么？

有问题的代码：

func (l *Loader) StartAsynchronous() []LoaderProcess {
    for _, currentProcess := range l.processes {
        cmd := exec.Command(currentProcess.Command, currentProcess.Arguments...)
        log.LogMessage("Asynchronously executing LoaderProcess: %+v", currentProcess)
        go func() {
            output, err := cmd.CombinedOutput()
            if err != nil {
                log.LogMessage("LoaderProcess exited with error status: %+v\n %v", currentProcess, err.Error())
            } else {
                log.LogMessage("LoaderProcess exited successfully: %+v", currentProcess)
                currentProcess.Log.LogMessage(string(output))
            }
            time.Sleep(time.Second * TIME_BETWEEN_SUCCESSIVE_ITERATIONS)
        }()
    }
    return l.processes
}

我建议的解决方法：

func (l *Loader) StartAsynchronous() []LoaderProcess {
    for _, currentProcess := range l.processes {
        cmd := exec.Command(currentProcess.Command, currentProcess.Arguments...)
        log.LogMessage("Asynchronously executing LoaderProcess: %+v", currentProcess)
        localProcess := currentProcess
        go func() {
            output, err := cmd.CombinedOutput()
            if err != nil {
                log.LogMessage("LoaderProcess exited with error status: %+v\n %v", localProcess, err.Error())
            } else {
                log.LogMessage("LoaderProcess exited successfully: %+v", localProcess)
                localProcess.Log.LogMessage(string(output))
            }
            time.Sleep(time.Second * TIME_BETWEEN_SUCCESSIVE_ITERATIONS)
        }()
    }
    return l.processes
} 

但这真的能解决问题吗？我刚刚将引用从范围变量移动到另一个局部变量，其值基于我所在的每个循环的迭代。

Answer 1

不要觉得这对 Go 新手来说是一个常见的错误，是的，每个循环的 var currentProcess 都会发生变化，因此您的 goroutine 将使用切片中的最后一个进程 l .processes，你所要做的就是将变量作为参数传递给匿名函数，如下所示：

func (l *Loader) StartAsynchronous() []LoaderProcess {

    for ix := range l.processes {

        go func(currentProcess *LoaderProcess) {

            cmd := exec.Command(currentProcess.Command, currentProcess.Arguments...)
            log.LogMessage("Asynchronously executing LoaderProcess: %+v", currentProcess)

            output, err := cmd.CombinedOutput()
            if err != nil {
                log.LogMessage("LoaderProcess exited with error status: %+v\n %v", currentProcess, err.Error())
            } else {
                log.LogMessage("LoaderProcess exited successfully: %+v", currentProcess)
                currentProcess.Log.LogMessage(string(output))
            }

            time.Sleep(time.Second * TIME_BETWEEN_SUCCESSIVE_ITERATIONS)

        }(&l.processes[ix]) // passing the current process using index

    }

    return l.processes
}

Answer 2

对于那些寻找更简单示例的人：

这是错误的：

func main() {
  for i:=0; i<10; i++{
    go func(){

        // Here i is a "free" variable, since it wasn't declared
        // as an explicit parameter of the func literal, 
        // so IT'S NOT copied by value as one may infer. Instead,
        // the "current" value of i
        // (in most cases the last value of the loop) is used
        // in all the go routines once they are executed.

        processValue(i)

    }()
  }
}

func processValue(i int){
  fmt.Println(i)
}

不完全是错误，但可能导致意外行为，因为控制循环的变量 i 可能会从其他 go 例程更改。实际上是 go vet command 对此发出警报。 Go vet 有助于准确地发现这种可疑结构，它使用不能保证所有报告都是真实问题的启发式方法，但它可以找到编译器未捕获的错误。因此，不时运行它是一个好习惯。

Go Playground 在运行代码之前运行 go vet，您可以在运行中看到 here。

这是正确的：

func main() {
  for i:=0; i<10; i++{
    go func(differentI int){

        processValue(differentI)

    }(i) // Here i is effectively passed by value since it was
         // declared as an explicit parameter of the func literal
         // and is taken as a different "differentI" for each
         // go routine, no matter when the go routine is executed
         // and independently of the current value of i.
  }
}

func processValue(i int){
  fmt.Println(i)
}

我故意将 func 文字参数命名为 differentI 以表明它是一个不同的变量。这样做对于并发使用是安全的，go vet 不会抱怨，也不会出现奇怪的行为。您可以在here 中看到这一点。 （你什么都看不到，因为打印是在不同的 goroutine 上完成的，但程序会成功退出）

顺便说一句，func 文字基本上是一个匿名函数:)

Answer 3

是的，您所做的是正确修复此警告的最简单方法。

在修复之前，只有一个 single 变量，所有的 goroutine 都在引用它。这意味着他们看到的不是开始时的值，而是当前值。在大多数情况下，这是该范围内的最后一个。

Answer 4

如果您在 JS 中使用过 Javascript 和闭包，那么将其与 for 循环内的 setTimeout 的经典示例与使用迭代结束时循环 var 的最终值的 setTimeout 非常相似且易于比较.