Question

我正试图通过go中的频道实现并行处理和通信。

我基本上试图解决的是并行处理特定数据，并按顺序获得结果=＆gt;为此目的引入了Chunk类型（见下文）。

我只为每个块处理创建新通道并将它们保存在slice =＆gt;中我希望在之后迭代它们时订购。

我的程序的简化版本是（https://play.golang.org/p/RVtDGgUVCV）：

package main

import (
    "fmt"
)

type Chunk struct {
    from int
    to   int
}

func main() {
    chunks := []Chunk{
        Chunk{
            from: 0,
            to:   2,
        },
        Chunk{
            from: 2,
            to:   4,
        },
    }

    outChannels := [](<-chan struct {
        string
        error
    }){}

    for _, chunk := range chunks {
        outChannels = append(outChannels, processChunk(&chunk))
    }

    for _, outChannel := range outChannels {
        for out := range outChannel {
            if out.error != nil {
                fmt.Printf("[ERROR] %s", out.error)
                return
            }

            fmt.Printf("[STDOUT] %s", out.string)
        }
    }
}

func processChunk(c *Chunk) <-chan struct {
    string
    error
} {

    outChannel := make(chan struct {
        string
        error
    })

    go func() {
        outChannel <- struct {
            string
            error
        }{fmt.Sprintf("from: %d to: %d\n", c.from, c.to), nil}

        close(outChannel)
    }()

    return outChannel
}

我看到的输出是：

[STDOUT] from: 2 to: 4
[STDOUT] from: 2 to: 4

我希望看到的是：

[STDOUT] from: 0 to: 2
[STDOUT] from: 2 to: 4

我在这里做错了什么？我没有看到它。

Answer 1

问题出在for的第一个main循环中。当您使用for range循环时，循环变量（此处为chunk）将被创建一次，并为每次迭代分配每个切片元素的副本。

当您调用processChunk(&chunk)时，您传递此循环变量的地址，并且此变量的值随每次迭代而变化。因此，函数processChunk总是最终处理chunks循环中的最后一项，因为这是{for循环结束后*chunk指向的内容。

要修复，请使用切片索引：

for i := 0; i < len(chunks); i++ {
    // pass chunk objects by indexing chunks
    outChannels = append(outChannels, processChunk(&chunks[i]))
}

固定代码：https://play.golang.org/p/A1_DtkncY_

您可以详细了解range here。

按顺序从golang频道中读取

1 个答案: