循环遍历 go 例程时出现数组索引错误

Question

我正在使用sync 为两个函数循环运行 go 例程，以等待 go 例程完成，然后在循环外运行一个普通函数，例如：

func fetchStudentsAndTeachers(db *sqlx.DB, token string) {
    var students Students
    var teachers Teachers
    wg := &sync.WaitGroup{}
    // defer wg.Wait()
    tch := make(chan Teachers)
    schoolList := fetchActiveOrganization(DB)
    std := make(chan Students)
    for key, value := range schoolList {
        value2 := value
        fmt.Println(key, ":", value)
        wg.Add(1)
        go func() {
            defer wg.Done()
            std <- fetchStudentsFromSchool(wg, value2.CleverSchoolID, token)
        }()
        wg.Add(1)
        go func() {
            defer wg.Done()
            tch <- fetchTeachersFromSchool(wg, value2.CleverSchoolID, token)
        }()
        students = <-std
        // teachers = <-tch
    }
    wg.Wait() // It panics after this point
    UpdateOrganizationsAndUsers(DB)
    close(std)
    close(tch)
    fmt.Println(students)
    fmt.Println(teachers)
}

现在的问题是当我跳出循环时给我的索引超出范围错误。在从wg.Wait() 转发调试器的控制权后，我检查了在wg.Wait() 上使用了 delve 调试器。它惊慌失措地说：

恐慌：运行时错误：索引超出范围

（已编辑） 注意：此问题是由于循环迭代一次并运行处理数据库的例程。但不知何故，在导致错误的例程完成之前循环再次迭代。在下一次迭代之前我应该​​怎么做才能完成这两个例程。

Answer 1

如果您希望 2 个工作 goroutine 在下一次迭代开始之前完成，只需将 wg.Wait() 调用移动到循环体的末尾即可：

for key, value := range schoolList {
    value2 := value
    fmt.Println(key, ":", value)
    wg.Add(1)
    go func() {
        defer wg.Done()
        std <- fetchStudentsFromSchool(wg, value2.CleverSchoolID, token)
    }()
    wg.Add(1)
    go func() {
        defer wg.Done()
        tch <- fetchTeachersFromSchool(wg, value2.CleverSchoolID, token)
    }()
    students = <-std
    teachers = <-tch
    wg.Wait()
}

另外请注意，如果您已经使用通道来传递 goroutine 结果，并且如果没有其他人使用 std 和 tch 通道，则甚至不需要 WaitGroup：

for key, value := range schoolList {
    value2 := value
    fmt.Println(key, ":", value)
    go func() {
        std <- fetchStudentsFromSchool(wg, value2.CleverSchoolID, token)
    }()
    go func() {
        tch <- fetchTeachersFromSchool(wg, value2.CleverSchoolID, token)
    }()
    students = <-std
    teachers = <-tch
}

这就足够了，因为只有在从 std 和 tch 的接收都完成时才能开始下一次迭代，但只有在工作 goroutine 完成工作并在这些通道上发送结果时才会发生。

现在，如果我们考虑一下它的作用：循环的 goroutine 等待 2 个工作 goroutine 完成它们的工作，然后继续（到下一次迭代）。当 2 名工人工作时，它只是在等待。

我们可以通过在循环的 goroutine 中完成 1 个工作人员的工作来简化和改进这一点，完成后，等待单个工作人员也完成（如果尚未完成）。

这就是它的样子：

for key, value := range schoolList {
    value2 := value
    fmt.Println(key, ":", value)
    go func() {
        std <- fetchStudentsFromSchool(wg, value2.CleverSchoolID, token)
    }()
    teachers = fetchTeachersFromSchool(wg, value2.CleverSchoolID, token)
    students = <-std
}

我们只是在循环的 goroutine 中获取教师，并且只在并发 goroutine 中获取学生。这具有相同的效果（学生和教师同时获取），开销更少，代码更简洁。

还请注意，由于您现在有了同步功能，在工作人员完成之前不会开始下一次迭代，因此您不需要复制循环变量：在工作人员的生命周期内不会修改它。所以你可以简单地使用：

for key, value := range schoolList {
    fmt.Println(key, ":", value)
    go func() {
        std <- fetchStudentsFromSchool(wg, value.CleverSchoolID, token)
    }()
    teachers = fetchTeachersFromSchool(wg, value.CleverSchoolID, token)
    students = <-std
}

（这也适用于带有等待组的解决方案。）