• 14.8 惰性生成器的实现
    • 链接

    14.8 惰性生成器的实现

    生成器是指当被调用时返回一个序列中下一个值的函数，例如：

    1.     generateInteger() => 0
    2.     generateInteger() => 1
    3.     generateInteger() => 2
    4.     ....

    生成器每次返回的是序列中下一个值而非整个序列；这种特性也称之为惰性求值：只在你需要时进行求值，同时保留相关变量资源（内存和cpu）：这是一项在需要时对表达式进行求值的技术。例如，生成一个无限数量的偶数序列：要产生这样一个序列并且在一个一个的使用可能会很困难，而且内存会溢出！但是一个含有通道和go协程的函数能轻易实现这个需求。

    在14.12的例子中，我们实现了一个使用int型通道来实现的生成器。通道被命名为yield和resume，这些此经常在协程代码中使用。

    Listing 14.12-lazy evaluation.go

    1. package main
    2. import (
    3.     "fmt"
    4. )
    6. var resume chan int
    8. func integers() chan int {
    9.     yield := make(chan int)
    10.     count := 0
    11.     go func() {
    12.         for {
    13.             yield <- count
    14.             count++
    15.         }
    16.     }()
    17.     return yield
    18. }
    20. func generateInteger() int {
    21.     return <-resume
    22. }
    24. func main() {
    25.     resume = integers()
    26.     fmt.Println(generateInteger())  //=> 0
    27.     fmt.Println(generateInteger())  //=> 1
    28.     fmt.Println(generateInteger())  //=> 2    
    29. }

    有一个细微的区别是从通道读取的值可能会是稍早前产生的，并不是在程序被调用时生成的。如果确实需要这样的行为，就得实现一个请求响应机制。当生成器生成数据的过程是计算密集型且各个结果的顺序并不重要时，那么就可以将生成器放入到go协程实现并行化。但是得小心，使用大量的go协程的开销可能会超过带来的性能增益。

    这些原则可以概括为：通过巧妙地使用空接口、闭包和高阶函数，我们能实现一个通用的惰性生产器的工厂函数BuildLazyEvaluator（这个应该放在一个工具包中实现）。工厂函数需要一个函数和一个初始状态作为输入参数，返回一个无参、返回值是生成序列的函数。传入的函数需要计算出下一个返回值以及下一个状态参数。在工厂函数中，创建一个通道和无限循环的go协程。返回值被放到了该通道中，返回函数稍后被调用时从该通道中取得该返回值。每当取得一个值时，下一个值即被计算。在下面的例子中，定义了一个evenFunc函数，其是一个惰性生成函数：在main函数中，我们创建了前10个偶数，每个都是通过调用even()函数取得下一个值的。为此，我们需要在BuildLazyIntEvaluator函数中具体化我们的生成函数，然后我们再在

    ** Listing 14.13: general lazy evaluation1.go

    1. package main
    2. import (
    3.     "fmt"
    4. )
    6. type Any interface{}
    7. type EvalFunc func(Any) (Any, Any)
    9. func main() {
    10.     evenFunc := func(state Any) (Any, Any) {
    11.         os := state.(int)
    12.         ns := os + 2
    13.         return os, ns
    14.     }
    16.     even := BuildLazyIntEvaluator(evenFunc, 0)
    18.     for i := 0; i < 10; i++ {
    19.         fmt.Printf("%vth even: %v\n", i, even())
    20.     }
    21. }
    23. func BuildLazyEvaluator(evalFunc EvalFunc, initState Any) func() Any {
    24.     retValChan := make(chan Any)
    25.     loopFunc := func() {
    26.         var actState Any = initState
    27.         var retVal Any
    28.         for {
    29.             retVal, actState = evalFunc(actState)
    30.             retValChan <- retVal
    31.         }
    32.     }
    33.     retFunc := func() Any {
    34.         return <- retValChan
    35.     }
    36.     go loopFunc()
    37.     return retFunc
    38. }
    40. func BuildLazyIntEvaluator(evalFunc EvalFunc, initState Any) func() int {
    41.     ef := BuildLazyEvaluator(evalFunc, initState)
    42.     return func() int {
    43.         return ef().(int)
    44.     }
    45. }

    输出：

    1. 0th even: 0
    2. 1th even: 2
    3. 2th even: 4
    4. 3th even: 6
    5. 4th even: 8
    6. 5th even: 10
    7. 6th even: 12
    8. 7th even: 14
    9. 8th even: 16
    10. 9th even: 18

    联系14.12：general_lazy_evaluation2.go
    通过使用14.12中工厂函数生成前10个斐波那契数

    提示：因为斐波那契数增长很迅速，使用uint64类型。
    注：这种计算通常被定义为递归函数，但是在没有尾递归的语言中，例如go语言，这可能会导致栈溢出，但随着go语言中堆栈可扩展的优化，这个问题就不那么严重。这里使用的诀窍使用了惰性求值。gccgo编译器在某些情况下会实现尾递归。

    链接

    • 目录
    • 上一节：新旧模型对比：任务和worker
    • 下一节：Implementing Futures