Go语言中该通道使用方式是否正确？代码阻塞无法完成如何处理？

嘿，我来帮你拆解下这个问题～你的代码阻塞无法完成，大概率是没处理好goroutine的等待逻辑或者通道的发送/接收闭环，先给你梳理下常见的坑和正确的用法：

常见错误场景 #

举个你可能遇到的错误代码示例（模拟你的场景）：

package main

import "fmt"

func main() {
    res := []int{1, 2, 3}
    for _, item := range res {
        go func(i int) {
            ch := make(chan int, 3)
            // 启动3个子goroutine
            for j := 0; j < 3; j++ {
                go func(k int) {
                    ch <- i*10 + k
                }(j)
            }
            // 假设这里只接收部分数据或者没处理完
            for val := range ch {
                fmt.Println(val)
            }
        }(item)
    }
    // 没有等待外层goroutine完成，主goroutine直接退出？或者内层通道没关闭导致range阻塞？
}

上面代码的核心问题：

• 内层的缓冲通道ch没有关闭，导致for val := range ch会一直阻塞——通道未关闭时，range会持续等待新数据输入；
• 主goroutine没有等待所有外层goroutine完成，可能主goroutine先退出，剩余goroutine还没执行完就被强制终止；
• 哪怕缓冲通道的容量刚好匹配发送数量，只要接收方没收到全部数据或通道没关闭，依然会出现阻塞。

正确的使用方式 #

要解决阻塞问题，需要做到两点：确保所有子goroutine完成后关闭通道，确保主goroutine等待所有外层goroutine完成。结合sync.WaitGroup来实现会更清晰：

package main

import (
    "fmt"
    "sync"
)

func main() {
    res := []int{1, 2, 3}
    var outerWG sync.WaitGroup

    for _, item := range res {
        outerWG.Add(1)
        go func(i int) {
            defer outerWG.Done() // 外层goroutine完成时标记

            ch := make(chan int, 3)
            var innerWG sync.WaitGroup

            // 启动3个子goroutine
            for j := 0; j < 3; j++ {
                innerWG.Add(1)
                go func(k int) {
                    defer innerWG.Done()
                    ch <- i*10 + k
                }(j)
            }

            // 单独启动goroutine等待内层完成后关闭通道，避免阻塞接收逻辑
            go func() {
                innerWG.Wait()
                close(ch)
            }()

            // 接收所有数据
            for val := range ch {
                fmt.Println(val)
            }
        }(item)
    }

    outerWG.Wait() // 主goroutine等待所有外层goroutine完成
    fmt.Println("程序执行完成")
}

关键要点总结 #

• 缓冲通道本身的使用是合法的：它只是允许一定数量的数据在未被接收时不阻塞发送方，但不代表可以忽略接收和关闭逻辑；
• 用for range遍历通道时，必须关闭通道才能让循环退出，否则会一直阻塞等待新数据；
• 嵌套goroutine场景下，一定要用sync.WaitGroup（或其他同步机制）等待所有goroutine完成，避免主goroutine提前退出；
• 内层通道的关闭时机很重要：必须等所有发送goroutine完成后再关闭，所以需要单独开一个goroutine来等待内层WG完成后关闭通道，否则会和接收操作产生死锁。

内容的提问来源于stack exchange，提问作者sumit