1. 并发遍历二叉树的需求与挑战
在go语言中，我们经常需要利用其强大的并发特性来处理数据结构，例如二叉树。一个常见的场景是，通过中序遍历将二叉树中的所有值发送到一个通道中，以便后续处理或比较。例如，要判断两棵二叉树是否等价（即包含相同的值且顺序一致），我们可以并发地遍历它们，将各自的值发送到独立的通道，然后从这两个通道中读取值进行比较。
然而，在递归实现的遍历函数中，正确关闭通道是一个常见的陷阱。如果简单地在递归函数内部调用 close(ch)，可能会导致通道在所有值发送完成之前就被关闭，从而引发运行时错误或逻辑错误。
2. 初始尝试与常见误区
考虑一个典型的二叉树中序遍历函数 Walk，它将树 t 中的所有值发送到通道 ch：
package main
import (
"fmt"
"golang.org/x/tour/tree" // 假设这个包提供了tree.Tree结构和New函数
)
// Walk 函数将二叉树 t 的所有值发送到通道 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)
}
// 错误示范：如果在这里 close(ch)，会过早关闭通道
// close(ch)
}如果尝试在 Walk 函数的末尾直接调用 close(ch)，会发现它在递归调用返回时就被执行，而不是在整个树遍历完成之后。例如，当 Walk(t.Left, ch) 返回时，t 节点的 close(ch) 就会执行，而此时 t 节点的 Value 和 t.Right 的值可能还未发送。这会导致后续的发送操作（ch
3. 优雅的解决方案：defer与闭包的结合
解决这个问题的关键在于确保 close(ch) 仅在整个 Walk 操作（包括所有递归子调用）完全结束后才执行。Go语言的 defer 语句非常适合这个场景，它会延迟函数的执行直到包含它的函数返回。然而，defer close(ch) 放在递归函数内部仍然会有问题。
立即学习“go语言免费学习笔记（深入）”；
正确的做法是将 defer close(ch) 放在 Walk 函数的外部，并使用一个内部的闭包来封装实际的递归逻辑。这样，外部的 Walk 函数会在启动内部递归后立即返回，而 defer close(ch) 会在 Walk 函数返回时执行，但此时由于内部闭包仍在执行，通道并不会立即关闭。当内部闭包的所有递归调用都完成，并且外部 Walk 函数真正“完成”其任务时（即没有其他goroutine持有对通道的引用），defer 就会触发。
以下是使用 defer 和闭包改进后的 Walk 函数：
package main
import (
"fmt"
"golang.org/x/tour/tree" // 假设这个包提供了tree.Tree结构和New函数
)
// Walk 函数将二叉树 t 的所有值发送到通道 ch
// 并在所有值发送完毕后关闭通道。
func Walk(t *tree.Tree, ch chan int) {
// defer close(ch) 确保通道在 Walk 函数返回时关闭。
// 由于递归逻辑被封装在内部闭包中，这个 defer 会在所有递归完成后才执行。
defer close(ch)
// 定义一个内部闭包，用于执行实际的递归遍历
var walk func(t *tree.Tree)
walk = func(t *tree.Tree) {
if t == nil {
return
}
walk(t.Left) // 遍历左子树
ch <- t.Value // 发送当前节点值
walk(t.Right) // 遍历右子树
}
walk(t) // 启动内部闭包的遍历
}在这个改进的 Walk 函数中：
- defer close(ch) 放在了 Walk 函数的顶部。这意味着 close(ch) 将在 Walk 函数执行完毕并返回时才会被调用。
- 实际的递归遍历逻辑被封装在一个名为 walk 的内部闭包中。
- 外部的 Walk 函数只负责设置 defer 和启动内部的 walk 闭包。
当 Walk(t, ch) 被调用时，它会设置 defer close(ch)，然后调用 walk(t)。walk(t) 会进行递归调用，将所有值发送到 ch。只有当 walk(t) 的所有递归调用都完成，walk(t) 函数执行完毕，并且 Walk 函数也即将返回时，defer close(ch) 才会真正执行，从而正确地关闭通道。
4. 判断二叉树等价性
有了正确关闭通道的 Walk 函数，我们现在可以实现 Same 函数来判断两棵二叉树 t1 和 t2 是否包含相同的值。
// Same 函数判断两棵二叉树 t1 和 t2 是否包含相同的值。
func Same(t1, t2 *tree.Tree) bool {
ch1 := make(chan int)
ch2 := make(chan int)
// 启动两个 goroutine 并发遍历两棵树
go Walk(t1, ch1)
go Walk(t2, ch2)
// 从两个通道中读取值并进行比较
for {
v1, ok1 := <-ch1 // 从 ch1 读取值
v2, ok2 := <-ch2 // 从 ch2 读取值
switch {
case !ok1 && !ok2: // 两个通道都已关闭，且之前所有值都匹配
return true
case !ok1 || !ok2: // 一个通道关闭，另一个仍有值，表示不相等
return false
case v1 != v2: // 值不匹配，表示不相等
return false
}
// 如果两个通道都有值且值匹配，则继续循环
}
}在 Same 函数中：
- 我们为两棵树分别创建了两个通道 ch1 和 ch2。
- 通过 go Walk(t1, ch1) 和 go Walk(t2, ch2)，我们并发地启动了两个 goroutine 来遍历两棵树，并将它们的值发送到各自的通道。
- 使用一个无限循环 for {} 来持续从两个通道中读取值。
- v1, ok1 :=
-
switch 语句处理四种情况：
- !ok1 && !ok2: 如果两个通道都已关闭，并且之前所有的值都匹配，则两棵树等价，返回 true。
- !ok1 || !ok2: 如果一个通道关闭而另一个仍有值，说明两棵树的节点数量或结构不一致，因此不等价，返回 false。
- v1 != v2: 如果从两个通道中读取到的值不相等，则两棵树不等价，返回 false。
- 其他情况（即 ok1 和 ok2 都为 true 且 v1 == v2）：表示当前值匹配，继续循环读取下一个值。
5. 完整示例代码
将上述 Walk 和 Same 函数与 main 函数结合，形成一个完整的可运行示例：
package main
import (
"fmt"
"golang.org/x/tour/tree" // 引入 Go Tour 提供的 tree 包
)
// Walk 函数将二叉树 t 的所有值发送到通道 ch
// 并在所有值发送完毕后关闭通道。
func Walk(t *tree.Tree, ch chan int) {
defer close(ch) // 确保通道在 Walk 函数返回时关闭
var walk func(t *tree.Tree)
walk = func(t *tree.Tree) {
if t == nil {
return
}
walk(t.Left)
ch <- t.Value
walk(t.Right)
}
walk(t)
}
// Same 函数判断两棵二叉树 t1 和 t2 是否包含相同的值。
func Same(t1, t2 *tree.Tree) bool {
ch1 := make(chan int)
ch2 := make(chan int)
go Walk(t1, ch1)
go Walk(t2, ch2)
for {
v1, ok1 := <-ch1
v2, ok2 := <-ch2
switch {
case !ok1 && !ok2: // 两个通道都已关闭，且之前所有值都匹配
return true
case !ok1 || !ok2: // 一个通道关闭，另一个仍有值，表示不相等
return false
case v1 != v2: // 值不匹配，表示不相等
return false
}
}
}
func main() {
// 测试两棵等价的树
fmt.Println("tree.New(1) 和 tree.New(1) 是否等价:", Same(tree.New(1), tree.New(1))) // 预期输出: true
// 测试两棵不等价的树
fmt.Println("tree.New(1) 和 tree.New(2) 是否等价:", Same(tree.New(1), tree.New(2))) // 预期输出: false
// 测试两棵结构相同但值不同的树 (例如，使用不同的种子生成)
fmt.Println("tree.New(1) 和 tree.New(10) 是否等价:", Same(tree.New(1), tree.New(10))) // 预期输出: false
}6. 注意事项与总结
- defer 的执行时机：defer 语句会在其所在的函数即将返回时执行。在我们的解决方案中，defer close(ch) 放在了外部 Walk 函数中，因此它会在 Walk 函数（包括其内部闭包的所有递归调用）完全结束后才执行，从而避免了通道过早关闭的问题。
- 闭包的作用：闭包 walk 允许我们封装递归逻辑，同时让外部 Walk 函数能够设置 defer，并在 walk 执行期间保持通道的开放状态。
- 并发安全：通过 goroutine 和 channel，我们实现了并发的树遍历和值比较，这在处理大型树结构时可以提高效率。
- 通道比较逻辑：Same 函数中的 for 循环和 switch 语句是处理两个通道同步读取和比较的经典模式，它能正确判断通道是否关闭以及值是否匹配。
通过这种结合 defer 和闭包的模式，我们不仅解决了在递归并发操作中通道关闭的难题，还提供了一个清晰、健壮的框架来处理类似的数据流场景。这种模式在Go语言并发编程中具有广泛的应用价值。
