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

Question

我在循环中运行两个函数的 go 例程，用于sync等待 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(). 它惊慌失措地说：

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

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

标签： gogoroutine

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 个 worker 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
}

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