Question

Go-lang新手在这里。我正在尝试Go的Go of Go，并且遇到了关于频道的练习（https://tour.golang.org/concurrency/7）。想法是走两棵树，然后评估树是否相同。

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

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

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

A＆＃34;休息＆＃34;语句终止执行最内层＆＃34; for＆＃34;，＆＃34; switch＆＃34;或＆＃34;选择＆＃34;言。
见：http://golang.org/ref/spec#Break_statements
示例中的break语句终止了select语句，＆＃34; innermost＆＃34;声明。
所以添加标签：for循环前的ForLoop并添加 break 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

并看到：
Go Tour Exercise: Equivalent Binary Trees

Answer 2

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规范），因此它会转到＆＃39;默认值＆＃39; case，因为select是非阻塞的，只是从ForLoop断开，甚至没有填充out1和out2切片（可能，因为这些是goroutines）。因此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）。

谢谢，

使用select的Golang频道不会停止

2 个答案: