Question

我目前正在研究Tour of Go，我认为goroutines与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)
    }
}

这似乎有效。几个问题：

如果我将通道上的缓冲区大小调高为10，fibonacci会尽快填满10个其他位置，main会尽快消耗掉这些位置可以去。这是正确的吗？这样的性能比缓冲区大小1更高，但代价是内存，对吗？
由于频道没有被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. 传递明确数量的值以生成
2. 传递目标价值
3. 传递决定是否继续进行的功能
为生成器提供“退出”通道，自行测试值，并在适当时告诉它退出。

结束并实际回答你的问题：

由于上下文切换较少，增加通道大小有助于提高性能。在这个简单的例子中，性能和内存消耗都不会成为问题，但在其他情况下，缓冲通道通常是一个非常好的主意。在大多数情况下，make (chan int, 100)使用的内存似乎并不重要，但它很容易产生很大的性能差异。
你的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())
    }
}

Go中的Python风格生成器

4 个答案: