Go语言闭包中变量作用域为何总是获取循环结束后的值？

在Go语言中，闭包（closure）是一个函数值，它引用了其函数体之外的变量。闭包中的变量作用域问题，尤其是在循环中使用闭包时，常常会导致一些意想不到的行为。具体来说，闭包中的变量作用域总是获取循环结束后的值，这是因为闭包捕获的是变量的引用，而不是变量的值。

问题描述

考虑以下代码：

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        go func() {
            fmt.Println(i)
        }()
    }
    time.Sleep(time.Second) // 等待goroutine执行
}

你可能期望输出是 0, 1, 2，但实际上输出可能是 3, 3, 3 或其他不确定的值。这是因为所有的goroutine共享同一个变量 i 的引用，当goroutine执行时，i 的值可能已经变成了循环结束后的值（即 3）。

原因分析

1. 变量捕获：闭包捕获的是变量的引用，而不是变量的值。在上面的例子中，所有的goroutine都捕获了同一个 i 的引用。

2. 循环执行速度：循环的执行速度通常比goroutine的启动和调度要快得多。因此，当goroutine开始执行时，循环可能已经结束，i 的值已经变成了循环结束后的值。

解决方案

要解决这个问题，可以通过以下几种方式确保每个goroutine捕获的是不同的变量值：

1. 使用函数参数传递变量

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        go func(i int) {
            fmt.Println(i)
        }(i)
    }
    time.Sleep(time.Second) // 等待goroutine执行
}

在这个例子中，i 作为参数传递给匿名函数，每个goroutine都会捕获一个独立的 i 的副本。

2. 在循环内部创建新的变量

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        i := i // 创建新的变量
        go func() {
            fmt.Println(i)
        }()
    }
    time.Sleep(time.Second) // 等待goroutine执行
}

在这个例子中，i := i 创建了一个新的局部变量 i，每个goroutine捕获的是不同的 i 的副本。

3. 使用 sync.WaitGroup 等待goroutine完成

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Println(i)
        }(i)
    }
    wg.Wait() // 等待所有goroutine完成
}

在这个例子中，sync.WaitGroup 用于等待所有的goroutine完成，确保主程序不会提前退出。

总结

在Go语言中，闭包捕获的是变量的引用，而不是变量的值。因此，在循环中使用闭包时，如果不采取适当的措施，可能会导致所有goroutine共享同一个变量的引用，从而获取到循环结束后的值。通过传递参数、创建新的变量或使用 sync.WaitGroup 等方法，可以确保每个goroutine捕获到正确的变量值。