Go语言传值过多致通道无输出且触发死锁问题求助

死锁的核心是发送与接收的顺序导致的连锁阻塞：

• getResults函数的逻辑是先一次性将所有index发送到indexCh，完成后才开始从resultCh读取结果。
• 4个processValue协程处理完index后，会将结果发送到resultCh。当resultCh的缓冲（深度4）被填满后，processValue协程会阻塞在ch <- result{...}这一步，无法继续从indexCh读取新的index。
• 此时indexCh的缓冲也已被填满（深度4），getResults函数阻塞在indexCh <- i这一步，无法继续发送剩余的index。
• 最终所有goroutine都陷入阻塞状态：getResults阻塞在发送index，processValue阻塞在发送result，没有任何goroutine能推进执行，触发死锁。

临界值的由来：当totalValues=12时，刚好是缓冲深度×(协程数+1)（4×3），此时所有index能在resultCh被填满前全部发送完成；当totalValues>12时，发送过程中resultCh先被填满，引发连锁阻塞。

提供三种可行的解决思路：

1. 边发送index边接收结果 #

修改getResults的逻辑，不再先全量发送index，而是交替发送和接收，给resultCh腾出缓冲空间，让processValue协程能持续运行：

func getResults(indexCh chan int, resultCh chan result, totalValues int) {
    allFields := make([]int, totalValues)
    sent := 0
    received := 0

    for received < totalValues {
        // 尽可能发送index，直到缓冲满或发完所有
        for sent < totalValues && len(indexCh) < cap(indexCh) {
            indexCh <- sent
            println("Sent value", sent)
            sent++
        }
        // 接收一个结果
        value := <-resultCh
        println("Received result", value.index)
        allFields[value.index] = value.count
        received++
    }

    close(indexCh) // 关闭indexCh，让processValue协程退出
    println("Done processing")
}

2. 增大resultCh的缓冲至totalValues #

直接让resultCh的缓冲能容纳所有结果，这样processValue协程发送结果时不会阻塞，能持续处理所有index：

func main() {
    bufferDepth := 4
    totalValues := 15 // 假设需要处理15个值
    indexCh := make(chan int, bufferDepth)
    resultCh := make(chan result, totalValues) // 缓冲等于总处理数

    for i := 0; i < 4; i++ {
        go processValue(indexCh, resultCh)
    }

    getResults(indexCh, resultCh, totalValues)
    close(resultCh)
}

3. 使用同步组配合通道管理（可选） #

如果需要更严谨的协程生命周期管理，可以用sync.WaitGroup等待所有processValue协程完成，同时确保indexCh在发送完成后关闭（注意此方法仍需配合边发边收或足够大的resultCh缓冲，否则依然会出现死锁）：

import "sync"

func getResults(indexCh chan int, resultCh chan result, totalValues int, wg *sync.WaitGroup) {
    defer close(indexCh) // 发送完所有index后关闭通道
    allFields := make([]int, totalValues)

    for i := range allFields {
        indexCh <- i
        println("Sent value", i)
    }

    println("Sent all values")

    for i := 0; i < totalValues; i++ {
        value := <-resultCh
        println("Received result", value.index)
        allFields[value.index] = value.count
    }

    wg.Wait() // 等待所有processValue协程退出
    println("Done processing")
}

func processValue(indexCh chan int, ch chan result, wg *sync.WaitGroup) {
    defer wg.Done()
    for index := range indexCh {
        println("Received value", index)
        ch <- result{
            index: index,
            count: index * index,
        }
        println("Sent result", index)
    }
}

func main() {
    bufferDepth := 4
    totalValues := 15
    indexCh := make(chan int, bufferDepth)
    resultCh := make(chan result, bufferDepth)
    var wg sync.WaitGroup

    wg.Add(4)
    for i := 0; i < 4; i++ {
        go processValue(indexCh, resultCh, &wg)
    }

    getResults(indexCh, resultCh, totalValues, &wg)
    close(resultCh)
}

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