concurrency - 看懂代码 - Go 并发模式 : Daisy Chain

Question

我正在研究 Go 并发模式。

我不确定的一种模式是: Daisy Chain https://talks.golang.org/2012/concurrency.slide#39

我很难理解代码的控制流程。

谁能给我解释一下？

package main

import (
    "fmt"
)

func f(left, right chan int) {
    left <- 1 + <-right
}

func main() {
    const n = 10000

    leftmost := make(chan int)
    right := leftmost               //point B: what does these do ?
    left := leftmost

    for i := 0; i < n; i++ {
        right = make(chan int)
        go f(left, right)
        left = right                //point A
    }
    go func(c chan int) { c <- 1 }(right)  
    fmt.Println(<-leftmost)
}

结论:

1. channel 从右到左的流动。写是个好习惯 func f(left chan<- int, right <-chan int)而不是上面的原始函数签名。

2. “链式 react ”直到 c <- 1 才开始，当信号 1 发送到最右边的 channel 时， react 一直到最左端。打印出10001。

原因是 go channel block 'read' until received channel receive signal.

1. @Rick-777 展示了如何使用类似数组的结构以便于理解。因为每个 go 协程只有 6k 左右大。做个10k channel 也不错。

2. 我清理了 B 点周围的一些代码，用于 channel 初始化。这是源代码: http://play.golang.org/p/1kFYPypr0l

Answer 1

VonC已经给出了直接的回答。这里有一些进一步的评论。

稍微整理过的版本在 the playground 中，区别在于作为参数传递的 channel 明确指定了方向，即。 <-chan和 chan<- .这样做是一种很好的做法，因为编译器可以为您捕获更多错误。

一个替代和等效程序，其菊花链为 n goroutines 可以使用 channel 数组来编写。这使用更少的代码行分配相同的 channel 总数。参见 playground :

package main

import (
    "fmt"
)

func f(left chan<- int, right <-chan int) {
    left <- 1 + <-right
}

func main() {
    const n = 10000

    // first we construct an array of n+1 channels each being a 'chan int'
    var channels [n+1]chan int
    for i := range channels {
        channels[i] = make(chan int)
    }

    // now we wire n goroutines in a chain
    for i := 0; i < n; i++ {
        go f(channels[i], channels[i+1])
    }

    // insert a value into the right-hand end
    go func(c chan<- int) { c <- 1 }(channels[n])

    // pick up the value emerging from the left-hand end
    fmt.Println(<-channels[0])
}

我希望你现在能明白原来的程序是如何等同于这个程序的。有一个细微差别:原始程序不创建任何 channel 数组，因此使用的内存少一点。