Go 生成器模式

Go生成器模式是函数式编程中的一种设计模式，它允许开发者按需生成值序列，而无需预先计算并存储所有值。这种模式在Go语言中通过闭包和通道实现，特别适合处理惰性计算和无限序列的场景。

概念介绍

生成器模式的核心思想是将序列的生成过程封装为一个函数，每次调用时返回序列中的下一个值。与直接生成完整数组不同，生成器仅在需要时才计算值，从而节省内存并提高效率。

在Go中，生成器通常通过以下方式实现：

• 使用闭包维护内部状态
• 通过通道进行值传递
• 结合goroutine实现并发生成

基本实现

闭包实现

最简单的生成器可以使用闭包实现：

package main

import "fmt"

// 整数生成器
func counter(start int) func() int {
    n := start
    return func() int {
        n++
        return n - 1
    }
}

func main() {
    gen := counter(0)
    fmt.Println(gen()) // 输出: 0
    fmt.Println(gen()) // 输出: 1
    fmt.Println(gen()) // 输出: 2
}

通道实现

更常见的Go风格实现是使用通道：

package main

import "fmt"

// 生成整数序列
func countGenerator(max int) <-chan int {
    ch := make(chan int)
    go func() {
        for i := 0; i < max; i++ {
            ch <- i
        }
        close(ch)
    }()
    return ch
}

func main() {
    for num := range countGenerator(5) {
        fmt.Println(num) // 依次输出: 0 1 2 3 4
    }
}

高级应用

无限生成器

Go生成器可以轻松表示无限序列：

package main

import "fmt"

// 斐波那契数列生成器
func fibonacci() <-chan int {
    ch := make(chan int)
    go func() {
        a, b := 0, 1
        for {
            ch <- a
            a, b = b, a+b
        }
    }()
    return ch
}

func main() {
    fib := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(<-fib) // 输出前10个斐波那契数
    }
}

生成器管道

多个生成器可以组合成处理管道：

package main

import (
    "fmt"
    "math"
)

// 数字平方生成器
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

// 数字过滤生成器
func filter(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            if math.Mod(float64(n), 2) == 0 {
                out <- n
            }
        }
        close(out)
    }()
    return out
}

func main() {
    nums := countGenerator(10)       // 生成0-9
    squares := square(nums)         // 计算平方
    evens := filter(squares)        // 过滤偶数
    
    for n := range evens {
        fmt.Println(n) // 输出: 0 4 16 36 64
    }
}

graph LR A[countGenerator] --> B[square] B --> C[filter] C --> D[输出]

实际应用案例

日志处理系统

生成器模式非常适合处理大型日志文件：

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

// 日志行生成器
func logGenerator(filename string) <-chan string {
    ch := make(chan string)
    go func() {
        file, err := os.Open(filename)
        if err != nil {
            close(ch)
            return
        }
        defer file.Close()
        
        scanner := bufio.NewScanner(file)
        for scanner.Scan() {
            ch <- scanner.Text()
        }
        close(ch)
    }()
    return ch
}

// 错误日志过滤器
func errorFilter(in <-chan string) <-chan string {
    out := make(chan string)
    go func() {
        for line := range in {
            if strings.Contains(line, "ERROR") {
                out <- line
            }
        }
        close(out)
    }()
    return out
}

func main() {
    logs := logGenerator("app.log")
    errors := errorFilter(logs)
    
    for err := range errors {
        fmt.Println(err) // 输出所有包含ERROR的日志行
    }
}

并发任务调度

生成器可以用于任务分发系统：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

// 任务生成器
func taskGenerator(count int) <-chan int {
    ch := make(chan int)
    go func() {
        for i := 0; i < count; i++ {
            ch <- i
            time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
        }
        close(ch)
    }()
    return ch
}

// 工作池
func workerPool(tasks <-chan int, workerCount int) <-chan string {
    results := make(chan string)
    for i := 0; i < workerCount; i++ {
        go func(workerID int) {
            for task := range tasks {
                time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
                results <- fmt.Sprintf("Worker %d processed task %d", workerID, task)
            }
        }(i)
    }
    return results
}

func main() {
    tasks := taskGenerator(10)
    results := workerPool(tasks, 3)
    
    for i := 0; i < 10; i++ {
        fmt.Println(<-results)
    }
}

数学基础

生成器模式在数学上可以表示为：

$G(n)=\{\begin{array}{ll}\text{初始值}& \text{当 }n=0\\ f(G(n-1))& \text{当 }n>0\end{array}$

其中$G$是生成器函数，$f$是状态转换函数。

性能考虑

使用生成器模式时需注意：

• 通道操作有开销，对小数据集可能不划算
• 无限生成器需要手动控制终止条件
• 错误处理需通过额外通道实现
• 资源清理要确保生成器能正常退出

总结

Go生成器模式提供了：

• 惰性求值能力
• 内存高效的数据流处理
• 清晰的管道式代码结构
• 天然的并发支持

这种模式特别适合处理：

• 大数据集
• 无限或未知长度的序列
• 需要多阶段处理的数据流
• 并发任务分发场景

通过合理使用生成器模式，可以编写出更高效、更易维护的Go代码。