go - Go 中的 Python 样式生成器

Question

我目前正在完成Tour of Go，我认为 goroutine 的使用与 Python 生成器类似，尤其是在Question 66中。我认为 66 看起来很复杂，所以我将其重写为：

package main

import "fmt"

func fibonacci(c chan int) {
    x, y := 1, 1

    for {
        c <- x
        x, y = y, x + y
    }
}

func main() {
    c := make(chan int)
    go fibonacci(c)

    for i := 0; i < 10; i++ {
        fmt.Println(<-c)
    }
}

这似乎有效。几个问题：

1. 如果我将通道上的缓冲区大小设置为 10，fibonacci则会尽快填满 10 个其他点，并且main会尽快吃掉这些点。这是正确的吗？这会比以内存为代价的缓冲区大小为 1 更高效，对吗？
2. 由于通道没有被fibonacci发送者关闭，当我们在这里超出范围时会发生什么记忆？我的期望是一旦超出范围，通道及其上的所有内容都会被垃圾收集c。go fibonacci我的直觉告诉我，这可能不会发生。

Answer 1

是的，增加缓冲区大小可能会大大提高程序的执行速度，因为它会减少上下文切换的次数。Goroutines 不是垃圾收集的，但通道是。在您的示例中，fibonacci goroutine 将永远运行（等待另一个 goroutine 从通道 c 读取），并且通道 c 永远不会被销毁，因为 fib-goroutine 仍在使用它。

这是另一个明显不同的程序，它不缺少内存并且更类似于 Python 的生成器：

package main

import "fmt"

func fib(n int) chan int {
    c := make(chan int)
    go func() {
        x, y := 0, 1
        for i := 0; i <= n; i++ {
            c <- x
            x, y = y, x+y
        }
        close(c)
    }()
    return c
}

func main() {
    for i := range fib(10) {
        fmt.Println(i)
    }
}

或者，如果您不知道要生成多少个斐波那契数，则必须使用另一个退出通道，以便在生成器goroutine应该停止时向其发送信号。这是 golang 的教程https://tour.golang.org/concurrency/4中解释的内容。

Answer 2

我喜欢@tux21b 的回答；在fib()函数中创建通道使调用代码干净整洁。详细说明一下，如果在调用函数时无法告诉函数何时停止，则只需要一个单独的“退出”通道。如果您只关心“最多 X 的数字”，您可以这样做：

package main

import "fmt"

func fib(n int) chan int {
    c := make(chan int)

    go func() {
        x, y := 0, 1

        for x < n {
            c <- x
            x, y = y, x+y
        }

        close(c)
    }()

    return c
}

func main() {
    // Print the Fibonacci numbers less than 500
    for i := range fib(500) {
        fmt.Println(i)
    }
}

如果你想要做任何一个，这有点草率，但我个人更喜欢它而不是在调用者中测试条件，然后通过单独的通道发出退出信号：

func fib(wanted func (int, int) bool) chan int {
    c := make(chan int)

    go func() {
        x, y := 0, 1

        for i := 0; wanted(i, x); i++{
            c <- x
            x, y = y, x+y
        }

        close(c)
    }()

    return c
}

func main() {
    // Print the first 10 Fibonacci numbers
    for n := range fib(func(i, x int) bool { return i < 10 }) {
        fmt.Println(n)
    }

    // Print the Fibonacci numbers less than 500
    for n := range fib(func(i, x int) bool { return x < 500 }) {
        fmt.Println(n)
    }
}

我认为这取决于特定情况的细节，您是否：

1. 创建生成器时告诉生成器何时停止
   1. 传递明确数量的值以生成
   2. 传递目标值
   3. 传递一个决定是否继续执行的函数
2. 给生成器一个“退出”通道，自己测试值，并告诉它在适当的时候退出。

总结并实际回答您的问题：

1. 由于更少的上下文切换，增加通道大小将有助于提高性能。在这个简单的示例中，性能和内存消耗都不会成为问题，但在其他情况下，缓冲通道通常是一个非常好的主意。在大多数情况下，使用的内存make (chan int, 100)似乎并不显着，但它很容易产生很大的性能差异。

2. 你的fibonacci函数中有一个无限循环，所以运行它的 goroutine 将永远运行（c <- x在这种情况下阻塞）。（一旦c超出调用者的范围）您将永远不会再从与它共享的频道中读取这一事实并不会改变这一点。正如@tux21b 指出的那样，通道永远不会被垃圾收集，因为它仍在使用中。这与关闭通道无关（其目的是让通道的接收端知道不会有更多值出现）以及与不从您的函数返回有关的一切。

Answer 3

您可以使用闭包来模拟生成器。这是来自golang.org的示例。

package main

import "fmt"

// fib returns a function that returns
// successive Fibonacci numbers.
func fib() func() int {
    a, b := 0, 1
    return func() int {
        a, b = b, a+b
        return a
    }
}

func main() {
    f := fib()
    // Function calls are evaluated left-to-right.
    fmt.Println(f(), f(), f(), f(), f())
}

Answer 4

使用通道来模拟 Python 生成器是可行的，但是它们在不需要的地方引入了并发，并且它增加了比可能需要的更多的复杂性。在这里，明确地保持状态更容易理解、更短，而且几乎可以肯定更有效。它使您对缓冲区大小和垃圾收集的所有问题都变得毫无意义。

type fibState struct {
    x, y int
}

func (f *fibState) Pop() int {
    result := f.x
    f.x, f.y = f.y, f.x + f.y
    return result
}

func main() {
    fs := &fibState{1, 1}
    for i := 0; i < 10; i++ {
        fmt.Println(fs.Pop())
    }
}