使用select的Golang频道不会停止

Question

高朗新手来了。我正在尝试围棋之旅，遇到了一个关于渠道（https://tour.golang.org/concurrency/7）的练习。这个想法是走两棵树，然后评估这些树是否相等。

我想使用select等待两个通道的结果来解决此练习。当这两个都完成时，我对结果切片进行评估。不幸的是，该方法在无限循环中进行。我添加了一些输出以查看发生了什么，并注意到只有一个通道被关闭，然后再次打开。

我显然做错了什么，但我看不出是什么。我的问题是我做错了什么？关于关闭通道，使下面的代码进入无限循环，我做了什么假设？

package main

import (
    "golang.org/x/tour/tree"
    "fmt"
)

// Walk walks the tree t sending all values
// from the tree to the channel ch.
func Walk(t *tree.Tree, ch chan int) {
    _walk(t, ch)
    close(ch)
}

func _walk(t *tree.Tree, ch chan int) {
    if (t.Left != nil) {
        _walk(t.Left, ch)
    }
    ch <- t.Value
    if (t.Right != nil) {
        _walk(t.Right, ch)
    }
}

// Same determines whether the trees
// t1 and t2 contain the same values.
func Same(t1, t2 *tree.Tree) bool {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go Walk(t1, ch1)
    go Walk(t2, ch2)

    var out1 []int
    var out2 []int

    var tree1open, tree2open bool
    var tree1val, tree2val int
    for {
        select {
        case tree1val, tree1open = <- ch1:
            out1 = append(out1, tree1val)
        case tree2val, tree2open = <- ch2:
            out2 = append(out2, tree2val)
        default:
            if (!tree1open && !tree2open) {
                break
            } else {
                fmt.Println("Channel open?", tree1open, tree2open)
            }
        }
    }

    if (len(out1) != len(out2)) {
        return false
    }

    for i := 0 ; i < len(out1) ; i++ {
        if (out1[i] != out2[i]) {
            return false
        }
    }

    return true
}

func main() {
    ch := make(chan int)
    go Walk(tree.New(1), ch)

    for i := range ch {
        fmt.Println(i)
    }

    fmt.Println(Same(tree.New(1), tree.New(1)))
    fmt.Println(Same(tree.New(1), tree.New(2)))
}

Answer 1

Amd的建议在前面的回答中是有效的。然而，看着你试图解决的问题，它仍然不能解决问题。（如果运行该程序，则在这两种情况下都将输出true）

问题是：

for {
    select {
    case tree1val, tree1open = <-ch1:
        out1 = append(out1, tree1val)
    case tree2val, tree2open = <-ch2:
        out2 = append(out2, tree2val)
    default:
        //runtime.Gosched()
        if !tree1open && !tree2open {
            break ForLoop
        } else {
            fmt.Println("Channel open?", tree1open, tree2open)
        }
    }
}

在这种情况下，由于tree1open和tree2open的默认值为false（根据golang规范），因此转到“default”情况，因为select是非阻塞的，只是从ForLoop中断，甚至没有填充out1和out2切片（可能，因为它们是goroutine）。因此out1和out2的长度保持为零，因此在大多数情况下输出为真。

更正如下：

ForLoop:
for {
    select {
    case tree1val, tree1open = <-ch1:
        if tree1open {
            out1 = append(out1, tree1val)
        }
        if !tree1open && !tree2open {
            break ForLoop
        }
    case tree2val, tree2open = <-ch2:
        if tree2open {
            out2 = append(out2, tree2val)
        }
        if !tree1open && !tree2open {
            break ForLoop
        }
    default:

    }
}

需要注意的关键是，我们必须检查两种情况下的通道是否都已关闭（相当于说tree1open和tree2open是否都为假）。在这里，它将正确填充out1和out2切片，然后进一步比较它们各自的值。

在追加之前添加了对tree1open（或tree2open）是否为true的检查，以避免将零值追加到out1（或out2）。

谢谢

Answer 2

参见：http://golang.org/ref/spec#Break_statements
示例中的打破语句终止了选择语句，也就是最内部的语句。
所以在for之前添加标签：ForLoop循环并添加中断ForLoop

ForLoop:
    for {
        select {
        case tree1val, tree1open = <-ch1:
            if tree1open {
                out1 = append(out1, tree1val)
            } else if !tree2open {
                break ForLoop
            }
        case tree2val, tree2open = <-ch2:
            if tree2open {
                out2 = append(out2, tree2val)
            } else if !tree1open {
                break ForLoop
            }
        }
    }

如果您想自己解决该问题，请不要阅读其余部分，完成后请返回：解决方案1（与您的类似）：

package main

import "fmt"
import "golang.org/x/tour/tree"

// Walk walks the tree t sending all values
// from the tree to the channel ch.
func Walk(t *tree.Tree, ch chan int) {
    _walk(t, ch)
    close(ch)
}

func _walk(t *tree.Tree, ch chan int) {
    if t.Left != nil {
        _walk(t.Left, ch)
    }
    ch <- t.Value
    if t.Right != nil {
        _walk(t.Right, ch)
    }
}

// Same determines whether the trees
// t1 and t2 contain the same values.
func Same(t1, t2 *tree.Tree) bool {
    ch1, ch2 := make(chan int), make(chan int)
    go Walk(t1, ch1)
    go Walk(t2, ch2)

    tree1open, tree2open := false, false
    tree1val, tree2val := 0, 0
    out1, out2 := make([]int, 0, 10), make([]int, 0, 10)
ForLoop:
    for {
        select {
        case tree1val, tree1open = <-ch1:
            if tree1open {
                out1 = append(out1, tree1val)
            } else if !tree2open {
                break ForLoop
            }
        case tree2val, tree2open = <-ch2:
            if tree2open {
                out2 = append(out2, tree2val)
            } else if !tree1open {
                break ForLoop
            }
        }
    }
    if len(out1) != len(out2) {
        return false
    }
    for i, v := range out1 {
        if v != out2[i] {
            return false
        }
    }
    return true
}

func main() {
    ch := make(chan int)
    go Walk(tree.New(1), ch)
    for i := range ch {
        fmt.Println(i)
    }
    fmt.Println(Same(tree.New(1), tree.New(1)))
    fmt.Println(Same(tree.New(1), tree.New(2)))
}

输出：

1
2
3
4
5
6
7
8
9
10
true
false    

另一种方式：

package main

import "fmt"
import "golang.org/x/tour/tree"

// Walk walks the tree t sending all values
// from the tree to the channel ch.
func Walk(t *tree.Tree, ch chan int) {
    _walk(t, ch)
    close(ch)
}

func _walk(t *tree.Tree, ch chan int) {
    if t != nil {
        _walk(t.Left, ch)
        ch <- t.Value
        _walk(t.Right, ch)
    }
}

// Same determines whether the trees
// t1 and t2 contain the same values.
func Same(t1, t2 *tree.Tree) bool {
    ch1, ch2 := make(chan int), make(chan int)
    go Walk(t1, ch1)
    go Walk(t2, ch2)
    for v := range ch1 {
        if v != <-ch2 {
            return false
        }
    }
    return true
}

func main() {
    ch := make(chan int)
    go Walk(tree.New(1), ch)
    for v := range ch {
        fmt.Println(v)
    }
    fmt.Println(Same(tree.New(1), tree.New(1)))
    fmt.Println(Same(tree.New(1), tree.New(2)))
}

输出：

1
2
3
4
5
6
7
8
9
10
true
false