Go并发编程：揭秘nil信道导致的死锁及其解决方案

package main

import (
    "fmt"
    "math/cmplx"
)

// max 函数模拟一个并发任务，计算切片中复数的最大绝对值
// 并将结果通过信道发送出去
func max(a []complex128, base int, ans chan float64, index chan int) {
    fmt.Printf("called for %d,%d\n", len(a), base)

    maxi_i := 0
    maxi := cmplx.Abs(a[maxi_i])

    for i := 1; i < len(a); i++ {
        if cmplx.Abs(a[i]) > maxi {
            maxi_i = i
            maxi = cmplx.Abs(a[i])
        }
    }

    fmt.Printf("called for %d,%d and found %f %d\n", len(a), base, maxi, base+maxi_i)

    // 尝试向信道发送数据
    ans <- maxi
    index <- base + maxi_i
}

func main() {
    ansData := make([]complex128, 128) // 示例数据
    numberOfSlices := 4
    incr := len(ansData) / numberOfSlices

    // 错误示例：创建了一个包含 nil 信道的切片
    // make([]chan float64, numberOfSlices) 仅分配了切片头和底层数组，
    // 数组中的每个元素（chan float64类型）都被初始化为其零值，即 nil。
    tmp_val := make([]chan float64, numberOfSlices)   // 这里的每个 chan 都是 nil
    tmp_index := make([]chan int, numberOfSlices) // 这里的每个 chan 都是 nil

    for i, j := 0, 0; j < numberOfSlices; j++ {
        fmt.Printf("From %d to %d - %d\n", i, i+incr, len(ansData))
        // 将 nil 信道传递给 Goroutine
        go max(ansData[i:i+incr], i, tmp_val[j], tmp_index[j])
        i = i + incr
    }

    // 主Goroutine尝试从这些 nil 信道接收数据，导致死锁
    // 由于 tmp_index[0] 和 tmp_val[0] 都是 nil 信道，
    // 尝试从它们接收数据会永久阻塞。
    fmt.Println("程序将在此处死锁，因为尝试从 nil 信道接收数据。")
    // 为了演示死锁，可以取消注释下面的代码行：
    // maximumFreq := <-tmp_index[0]
    // maximumMax := <-tmp_val[0]
    // for i := 1; i < numberOfSlices; i++ {
    //     tmpI := <-tmp_index[i]
    //     tmpV := <-tmp_val[i]
    //     if tmpV > maximumMax {
    //         maximumMax = tmpV
    //         maximumFreq = tmpI
    //     }
    // }
    // fmt.Printf("Max freq = %d\n", maximumFreq)
}

package main

import (
    "fmt"
    "math/cmplx"
)

// max 函数模拟一个并发任务，计算切片中复数的最大绝对值
// 并将结果通过信道发送出去
func max(a []complex128, base int, ans chan float64, index chan int) {
    fmt.Printf("called for %d,%d\n", len(a), base)

    maxi_i := 0
    maxi := cmplx.Abs(a[maxi_i])

    for i := 1; i < len(a); i++ {
        if cmplx.Abs(a[i]) > maxi {
            maxi_i = i
            maxi = cmplx.Abs(a[i])
        }
    }

    fmt.Printf("called for %d,%d and found %f %d\n", len(a), base, maxi, base+maxi_i)

    ans <- maxi
    index <- base + maxi_i
}

func main() {
    ansData := make([]complex128, 128) // 示例数据

    numberOfSlices := 4
    incr := len(ansData) / numberOfSlices

    // 正确示例：先创建切片，然后循环初始化切片中的每个信道
    tmp_val := make([]chan float64, numberOfSlices)
    tmp_index := make([]chan int, numberOfSlices)

    // 重点：遍历切片，为每个信道元素单独进行初始化
    for i := 0; i < numberOfSlices; i++ {
        tmp_val[i] = make(chan float64) // 初始化非缓冲信道
        tmp_index[i] = make(chan int)   // 初始化非缓冲信道
    }

    // 启动 Goroutine 并传递已初始化的信道
    for i, j := 0, 0; j < numberOfSlices; j++ {
        fmt.Printf("From %d to %d - %d\n", i, i+incr, len(ansData))
        go max(ansData[i:i+incr], i, tmp_val[j], tmp_index[j])
        i = i + incr
    }

    // 从已初始化的信道接收数据，不会再死锁
    maximumFreq := <-tmp_index[0]
    maximumMax := <-tmp_val[0]
    for i := 1; i < numberOfSlices; i++ {
        tmpI := <-tmp_index[i]
        tmpV := <-tmp_val[i]

        if tmpV > maximumMax {
            maximumMax = tmpV
            maximumFreq = tmpI
        }
    }

    fmt.Printf("Max freq = %d\n", maximumFreq) // 添加换行符使输出更清晰
}