下面是一个 Stuff 类型的结构。它有三个整数。 Number , 它的 Double及其 Power .让我们假设计算给定整数列表的 double 和幂是一项昂贵的计算。

type Stuff struct {
    Number int
    Double int
    Power  int
}

func main() {
    nums := []int{2, 3, 4} // given numbers
    stuff := []Stuff{}     // struct of stuff with transformed ints

    double := make(chan int)
    power := make(chan int)

    for _, i := range nums {
        go doubleNumber(i, double)
        go powerNumber(i, power)
    }

    // How do I get the values back in the right order?

    fmt.Println(stuff)
}

func doubleNumber(i int, c chan int) {
    c <- i + i
}

func powerNumber(i int, c chan int) {
    c <- i * i
}

fmt.Println(stuff) 的结果应该和东西初始化一样:

stuff := []Stuff{
    {Number: 2, Double: 4, Power: 4}
    {Number: 3, Double: 6, Power: 9}
    {Number: 4, Double: 8, Power: 16}
}

我知道我可以使用 <- double和 <- power从 channel 收集值(value)，但我不知道什么双倍/幂属于什么数字。

最佳答案

Goroutines 并发、独立运行，因此如果没有显式同步，您无法预测执行和完成顺序。因此，您不能将返回的数字与输入的数字配对。

您可以返回更多数据(例如输入数字和输出，例如包装在结构中)，或者将指针传递给工作函数(作为新的 goroutines 启动)，例如*Stuff 并让 goroutines 将计算的数据填充到 Stuff 本身。

返回更多数据

我将使用 channel 类型 chan Pair，其中 Pair 是:

type Pair struct{ Number, Result int }

因此计算将如下所示:

func doubleNumber(i int, c chan Pair) { c <- Pair{i, i + i} }

func powerNumber(i int, c chan Pair) { c <- Pair{i, i * i} }

我将使用 map[int]*Stuff 因为可收集的数据来自多个 channel (double 和 power)，而且我想要轻松快速地找到合适的 Stuff(需要指针，因此我也可以“在 map 中”修改它)。

所以主要功能:

nums := []int{2, 3, 4} // given numbers
stuffs := map[int]*Stuff{}

double := make(chan Pair)
power := make(chan Pair)

for _, i := range nums {
    go doubleNumber(i, double)
    go powerNumber(i, power)
}

// How do I get the values back in the right order?
for i := 0; i < len(nums)*2; i++ {
    getStuff := func(number int) *Stuff {
        s := stuffs[number]
        if s == nil {
            s = &Stuff{Number: number}
            stuffs[number] = s
        }
        return s
    }

    select {
    case p := <-double:
        getStuff(p.Number).Double = p.Result
    case p := <-power:
        getStuff(p.Number).Power = p.Result
    }
}

for _, v := range nums {
    fmt.Printf("%+v\n", stuffs[v])
}

输出(在 Go Playground 上尝试):

&{Number:2 Double:4 Power:4}
&{Number:3 Double:6 Power:9}
&{Number:4 Double:8 Power:16}

使用指针

因为现在我们正在传递 *Stuff 值，所以我们可以在 Stuff 本身中“预填充”输入数字。

但必须小心，您只能在适当同步的情况下读/写值。最简单的方法是等待所有“ worker ”goroutines 完成他们的工作。

var wg = &sync.WaitGroup{}

func main() {
    nums := []int{2, 3, 4} // given numbers

    stuffs := make([]Stuff, len(nums))
    for i, n := range nums {
        stuffs[i].Number = n
        wg.Add(2)
        go doubleNumber(&stuffs[i])
        go powerNumber(&stuffs[i])
    }
    wg.Wait()
    fmt.Printf("%+v", stuffs)
}

func doubleNumber(s *Stuff) {
    defer wg.Done()
    s.Double = s.Number + s.Number
}

func powerNumber(s *Stuff) {
    defer wg.Done()
    s.Power = s.Number * s.Number
}

输出(在 Go Playground 上尝试):

[{Number:2 Double:4 Power:4} {Number:3 Double:6 Power:9} {Number:4 Double:8 Power:16}]

同时写入不同的 slice 元素

另请注意，由于您可以同时写入不同的数组或 slice 元素(有关详细信息，请参阅 Can I concurrently write different slice elements )，因此您可以将结果直接写入没有 channel 的 slice 中。参见 Refactor code to use a single channel in an idiomatic way如何做到这一点。

关于go - 如何从按特定顺序执行的 N 个 goroutine 中收集值？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56916688/