Go语言中管理动态Goroutine与结果收集的并发模式

func outer(initialValues string) []int {
    results := make([]int, 0)
    resultsChannel := make(chan int)

    var inner func(arg string) // 声明一个函数类型变量

    inner = func(arg string) {
        // 模拟一些计算并发送结果
        result := len(arg) // 示例计算
        resultsChannel <- result

        // 模拟根据数据递归生成子任务
        // 实际场景中，recursionArguments可能来自arg的解析或处理
        recursionArguments := []string{}
        if result > 0 { // 简单示例：如果结果大于0，则可能继续递归
            recursionArguments = append(recursionArguments, arg[1:]) // 递归调用
            recursionArguments = append(recursionArguments, arg[0:len(arg)-1])
        }

        for _, subArg := range recursionArguments {
            go inner(subArg) // 在新的Goroutine中递归
        }
    }

    go inner(initialValues) // 启动初始Goroutine

    // 问题：如何知道何时停止从 resultsChannel 读取？
    for {
        select {
        case res, ok := <-resultsChannel:
            if !ok {
                // 通道已关闭，所有结果已读取
                return results
            }
            results = append(results, res)
        // default: // 如果没有default，这里会阻塞直到有数据或通道关闭
        }
    }
}

import (
    "fmt"
    "sync"
    "time"
)

func outerWithWaitGroup(initialValues string) []int {
    results := make([]int, 0)
    resultsChannel := make(chan int)
    var wg sync.WaitGroup // 声明 WaitGroup

    var inner func(arg string)

    inner = func(arg string) {
        defer wg.Done() // 确保无论Goroutine如何退出，计数器都会减少

        // 模拟一些计算并发送结果
        result := len(arg)
        resultsChannel <- result
        fmt.Printf("Goroutine for '%s' sent result: %d\n", arg, result)

        // 模拟根据数据递归生成子任务
        recursionArguments := []string{}
        if result > 1 { // 示例条件：长度大于1才继续递归
            recursionArguments = append(recursionArguments, arg[1:])
            recursionArguments = append(recursionArguments, arg[0:len(arg)-1])
        }

        for _, subArg := range recursionArguments {
            wg.Add(1) // 在启动新Goroutine之前增加计数器
            go inner(subArg)
        }
    }

    wg.Add(1) // 为初始Goroutine增加计数器
    go inner(initialValues)

    // ... 后续处理，等待所有Goroutine完成并关闭通道
    // 此处仅展示 WaitGroup 的使用，完整的解决方案见下文
    return results
}

import (
    "fmt"
    "sync"
    "time" // 仅用于模拟延迟，实际应用中可能不需要
)

func outerComplete(initialValue string) []int {
    results := make([]int, 0)
    resultsChannel := make(chan int)
    var wg sync.WaitGroup

    var inner func(arg string)

    inner = func(arg string) {
        defer wg.Done() // 确保 Goroutine 完成时调用 Done

        // 模拟计算并发送结果
        time.Sleep(time.Millisecond * 10) // 模拟工作耗时
        result := len(arg) + 10 // 示例计算
        resultsChannel <- result
        fmt.Printf("[Worker] Goroutine for '%s' sent result: %d\n", arg, result)

        // 模拟递归条件：如果字符串长度大于2，则继续分裂递归
        if len(arg) > 2 {
            subArgs := []string{arg[1:], arg[:len(arg)-1]} // 示例分裂逻辑
            for _, subArg := range subArgs {
                wg.Add(1) // 为新的 Goroutine 增加计数器
                go inner(subArg)
            }
        }
    }

    // 1. 启动一个 Goroutine 来等待所有工作 Goroutine 完成，然后关闭结果通道
    go func() {
        wg.Wait() // 阻塞直到所有 Goroutine 都调用了 Done()
        close(resultsChannel) // 所有结果都已发送，可以关闭通道
        fmt.Println("[Coordinator] All worker goroutines finished. Closing results channel.")
    }()

    // 2. 为初始 Goroutine 增加计数器并启动
    wg.Add(1)
    go inner(initialValue)

    // 3. 从结果通道读取所有结果，直到通道关闭
    fmt.Println("[Collector] Starting to collect results...")
    for res := range resultsChannel { // range 循环会在通道关闭时自动退出
        results = append(results, res)
        fmt.Printf("[Collector] Collected result: %d\n", res)
    }
    fmt.Println("[Collector] Results channel closed. Collection complete.")

    return results
}

func main() {
    fmt.Println("--- Starting outerComplete with 'helloworld' ---")
    finalResults := outerComplete("helloworld")
    fmt.Printf("Final collected results: %v\n", finalResults)
    fmt.Println("--- Finished outerComplete ---")

    fmt.Println("\n--- Starting outerComplete with 'abc' ---")
    finalResults2 := outerComplete("abc")
    fmt.Printf("Final collected results: %v\n", finalResults2)
    fmt.Println("--- Finished outerComplete ---")
}