goroutine 加 channel 代替递归调用，突破递归调用的层级限制

package main

import (
    "fmt"
    "github.com/davecgh/go-spew/spew"
    "github.com/BurntSushi/toml"
    "errors"
    "sync"
)

type kvData struct {
    Prefix string // 前缀
    Data map[string]interface{}
}

// 递归将所有的层级遍历出来
func unmarshal(m kvData, work chan kvData, result chan []map[string]interface{}, wg *sync.WaitGroup) (error) {
    defer wg.Done()
    var r []map[string]interface{}
    for k, v := range m.Data {
        switch v.(type) {
        case string, int64, float64, bool:
            r = append(r, map[string]interface{}{"k":m.Prefix + k, "v":v})
        case map[string]interface{}:
            wg.Add(2)
            work <- kvData{Prefix:m.Prefix + k + ".", Data : v.(map[string]interface{})}
        default:
            return errors.New("目前只能识别string、int、float、bool类型的配置")
        }
    }

    result <- r

    return nil
}

func main() {
    text := `
myip = "1.1.4.51"
type = "red"
[server]
  [server.http]
    addr="1.11.7.1:5"
  [server.grpc]
    addr="1.1.1.1:5"`

    var obj map[string]interface{}

    if e := toml.Unmarshal([]byte(text), &obj); e != nil {
        spew.Dump(e)
    }



    var work = make(chan kvData, 30)
    var result = make(chan []map[string]interface{}, 30)
    var wg sync.WaitGroup

    var r []map[string]interface{}

    wg.Add(2)
    if e := unmarshal(kvData{Prefix:"", Data:obj}, work, result, &wg); e != nil {
        fmt.Println(e)
        return
    }

    var end = make(chan int)
    go func() {
        for {
            select {
            case newWork := <-work:
                fmt.Println("w")
                spew.Dump(newWork)
                go unmarshal(newWork, work, result, &wg)
            case newResult := <-result:
                wg.Done()
                fmt.Println("r")
                spew.Dump(newResult)
                if len(newResult) != 0 {
                    r = append(r, newResult...)
                }
            case <-end:
                spew.Dump(r)
                return
            }
        }
    }()
    wg.Wait()
    end<-1

    fmt.Println("--all----\n")
    for _, v := range r {
        fmt.Println(" k => ", v["k"])
        fmt.Println(" v => ", v["v"])
    }

    return
}

 

1、创建两个channel（work，result）分别用来存放任务、返回结果。
2、创建一个结构体 kvData 来存放任务以及任务执行的环境依赖。
3、创建sync.WaitGroup 来等待所有的 goroutine 执行完成。

限制递归层级的原因就是递归的栈的释放是从最后一层倒退着向上释放的，其实限制递归层级的条件就是栈的容量。
goroutine 加 channel 在没层级的过程中都会将结果放回到结果的channel（result）、如果需要进一步分析就将需要进一步分析的任务放到 channel（work）中
一方面是并发在执行、一方面是不会造成栈的累积，因此不存在层级的限制。

注：
1、递归在数量比较少的时候速度和内存的占用量是比较好的（没有做具体的实验所有没有具体的数据）
2、goroutine 启动的时候大概需要占用4K的内容，针对于这样的递归来说还是比较大的一个开销
3、goroutine 应该做一个pool，然后反复使用