我是 Golang 初学者

我从 here. 读到关于 Go 中的并发性

在我收到关于 8th slide. 的问题之前，一切都很顺利
问题是:找出两个给定的二叉树是否等价。
我的方法:进行中序遍历，将两棵树的值保存在一个 slice 中并进行比较。

这是我的解决方案:[不完整]

package main

import (
    "fmt"
    "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) {
    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 := make(chan int)
    ch2 := make(chan int)

    go func() {
        fmt.Println("executing first go routing")
        Walk(t1, ch1)
        fmt.Println("closing channel [ch1]")
        close(ch1)
    }()

    go func() {
        fmt.Println("executing second go routing")
        Walk( t2, ch2 )
        fmt.Println("closing channel [ch2]")
        close(ch2)
    }()

    shouldContinue := true
    var continue1, continue2 bool
    for shouldContinue {
        select {
        case r1, ok1 := <-ch1:
            fmt.Println("[ch1] [rcvd]", r1)
            continue1 = ok1

        case r2, ok2 := <-ch2:
            fmt.Println("[ch2] [rcvd]", r2)
            continue2 = ok2
        }
        shouldContinue = continue1 || continue2
    }
    return true
}

func main() {
    Same(tree.New(1), tree.New(1))
}

我知道 goroutines 是协作调度的，如果一个 goroutine 正在循环或连续进行计算，它会完全阻塞另一个。所以我预计对于输出，它会首先从任一 channel 接收值，关闭它，然后它会从另一个 channel 接收值，然后关闭。一旦两者都关闭，for 循环就会中断。

令我惊讶的是，第一个 go 例程从未被安排好。这是我收到的输出:

executing second go routing
[ch2] [rcvd] 1
[ch2] [rcvd] 2
[ch2] [rcvd] 3
[ch2] [rcvd] 4
[ch2] [rcvd] 5
[ch2] [rcvd] 6
[ch2] [rcvd] 7
[ch2] [rcvd] 8
[ch2] [rcvd] 9
[ch2] [rcvd] 10
closing channel [ch2]
[ch2] [rcvd] 0 

谁能解释一下这是怎么回事？一旦 channel2 关闭并且第二个 go 例程完成，为什么第一个不执行？

如有任何帮助，我们将不胜感激。谢谢。

更新:
我在谷歌上搜索了关于突破 channel 的问题，我发现了一个 SO 问题 here. 据此，我更新了我的解决方案如下:

package main

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

// Walk walks the tree t sending all values
// from the tree to the channel ch.
func Walk(t *tree.Tree, ch chan int) {
    // time.Sleep(time.Millisecond)
    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 := make(chan int)
    ch2 := make(chan int)

    go func() {
        fmt.Println("executing first go routing")
        Walk(t1, ch1)
        fmt.Println("closing channel [ch1]")
        close(ch1)
    }()

    go func() {
        fmt.Println("executing second go routing")
        Walk( t2, ch2 )
        fmt.Println("closing channel [ch2]")
        close(ch2)
    }()

    for {
        select {
        case r1, ok1 := <-ch1:
            fmt.Println("[ch1] [rcvd]", r1)
            if !ok1 {
                ch1 = nil
            } 

        case r2, ok2 := <-ch2:
            fmt.Println("[ch2] [rcvd]", r2)
            if !ok2 {
                ch2 = nil
            }
        }
        if ch1 == nil && ch2 == nil {
            break
        }
    }
    return true
}

func main() {
    Same(tree.New(1), tree.New(1))
}

这给出了我认为第一个片段的确切输出:

executing second go routing
[ch2] [rcvd] 1
[ch2] [rcvd] 2
[ch2] [rcvd] 3
[ch2] [rcvd] 4
[ch2] [rcvd] 5
[ch2] [rcvd] 6
[ch2] [rcvd] 7
[ch2] [rcvd] 8
[ch2] [rcvd] 9
[ch2] [rcvd] 10
closing channel [ch2]
[ch2] [rcvd] 0
executing first go routing
[ch1] [rcvd] 1
[ch1] [rcvd] 2
[ch1] [rcvd] 3
[ch1] [rcvd] 4
[ch1] [rcvd] 5
[ch1] [rcvd] 6
[ch1] [rcvd] 7
[ch1] [rcvd] 8
[ch1] [rcvd] 9
[ch1] [rcvd] 10
closing channel [ch1]
[ch1] [rcvd] 0

我现在对发生的事情更加困惑。

最佳答案

Once channel2 is closed, why doesn't the first one gets executed?

channel 不执行。一遍又一遍地执行的是您的选择。请注意，无论 channel 是否关闭，这两种情况都可以始终执行。所以 select 可以选择 id 所做的第二种情况，而你中止了。 (您的中止条件看起来可疑:一旦两个 channel 关闭，即如果两个 ok1 和 ok2 都为假，您就完成了)。

不要将 select 本身视为“goroutine 调度工具”。它不是。它将随机选择一个可运行案例。如果你所有的案例都是 val, ok := <- ch 的形式比所有都可运行和选择可能总是选择第二个。或者第一个，或者...

[Second Solution] I am now even more confused about what is going on.

您的中止条件不同。一旦两个 channel 都为零，您就会中断，这会在两个 channel 都关闭后发生。这与您的第一个解决方案不同，因为一旦任何 一个 channel 关闭，第一个解决方案就会中断。

这里并发的问题不在于 goroutine 调度，而在于执行选择的 for 循环的中止条件。它们不同于第一个和第二个，第一个从根本上是错误的，因为一旦任何 channel 耗尽它就会停止。

关于go - 意外的协程行为，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54233678/