Question

有一个我想使用并发模型编写的函数，以防输入太大而并行处理会更有效，但是永远不会结束。

假设有一个struct定义为：

type Tree struct {
    Name     string   `json:"name"`
    SubTrees []*Tree  `json:"subTrees,omitempty"`
    Leaves   []string `json:"leaves"`
}

我想编写一个函数来计算整个递归结构中Leaves的总数。可以通过以下方式轻松实现递归：

func (tree *Tree) CountLeaves() int {
    curr := len(tree.Leaves)
    for _, s := range tree.SubTrees {
        curr += s.CountLeaves()
    }
    return curr
}

很好，但是，如果结构太大，效率将会降低，因此我想将其重构为并发并使用通道。这是我进行重构的尝试：

func (tree *Tree) CountLeaves() int {
    var wg sync.WaitGroup
    ch := make(chan int)
    defer close(ch)
    go count(tree, true, ch, &wg)

    var total int
    wg.Add(1)
    go func(total *int) {
        for x := range ch {
            fmt.Println(x)
            *total += x
        }
        wg.Done()
    }(&total)
    wg.Wait()

    return total
}

func count(t *Tree, root bool, ch chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    ch <- len(t.Leaves)
    if t.SubTrees != nil {
        wg.Add(len(t.SubTrees))
        for _, s := range t.SubTrees {
            go count(s, false, ch, wg)
        }
        wg.Wait()
    }

    if root {
        ch <- -1
    }
}

我现在能够通过当前需要计算Leaves总数的通道收集所有数字，但是函数永无止境。来自根-1结构的终止值Tree永远不会通过通道被推送或接收，我也不知道为什么。

有什么想法吗？

Answer 1

我很确定您的WaitGroup从未接到足够的wg.Done电话：

go func(total *int) {
    for x := range ch {
        fmt.Println(x)
        *total += x
    }
    wg.Done()
}(&total)

由于您从不关闭ch，因此在这里永远不会调用wg.Done。我认为，如果您将其移动到循环中：

go func(total *int) {
    for x := range ch {
        fmt.Println(x)
        *total += x
         wg.Done()
    }
}(&total)

这将解决问题。

编辑：

实际上，我认为还有一个问题：

defer wg.Done()
ch <- len(t.Leaves)
if t.SubTrees != nil {
    wg.Add(len(t.SubTrees))
    for _, s := range t.SubTrees {
        go count(s, false, ch, wg)
    }
    wg.Wait()
}

延迟的wg.Done()直到您返回之前都不会被呼叫，因此此wg.Wait()也将永远等待。这可能是：

ch <- len(t.Leaves)
if t.SubTrees != nil {
    wg.Add(len(t.SubTrees))
    for _, s := range t.SubTrees {
        go count(s, false, ch, wg)
    }
    wg.Done()
    wg.Wait()
} else {
    wg.Done()
}

同时计数树叶

1 个答案: