Go中的Python风格生成器

Question

我目前正在研究Tour of Go,我认为goroutines的使用方式与Python生成器类似,特别是问题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())
    }
}