Parallel processing go函数通道中的死锁

为什么会出现死锁，即使我只是传递一个，然后从通道中获得一个输出

package main

import "fmt"
import "math/cmplx"

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() {
    ans := make([]complex128,128)

    numberOfSlices := 4
    incr := len(ans)/numberOfSlices
    tmp_val := make([]chan float64,numberOfSlices)
    tmp_index := make([]chan int,numberOfSlices)
    for i,j := 0 , 0; i < len(ans); j++{
        fmt.Printf("From %d to %d - %d\n",i,i+incr,len(ans))
        go max(ans[i:i+incr],i,tmp_val[j],tmp_index[j])

        i = i+ incr
    }
//After Here is it stops deadlock
    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",maximumFreq)

}

主程序包
输入“fmt”
导入“数学/cmplx”
func max（a[]复数128，基整数，ans-chan-float64，索引chan-int）{
fmt.Printf（“调用%d，%d\n”，len（a），base）
最大值：=0
maxi:=cmplx.Abs（a[maxi_i]）；
对于i:=1；imaxi{
maxi_i=i
maxi=cmplx.Abs（a[i]）
}
}
fmt.Printf（“调用%d，%d并找到%f%d\n”，len（a），base，maxi，base+maxi_i）
ans我做禅是错的。我应该做的

numberOfSlices := 4
incr := len(ans)/numberOfSlices
var tmp_val [4]chan float64
var tmp_index [4]chan int

for i := range tmp_val {
    tmp_val[i] = make(chan float64)
    tmp_index[i] = make(chan int)
}

for i,j := 0 , 0; i < len(ans); j++{
    fmt.Printf("From %d to %d [j:%d] - %d\n",i,i+incr,j,len(ans))
    go maximumFunc(ans[i:i+incr],i,tmp_val[j],tmp_index[j])

    i = i+ incr
}

numberOfSlices:=4
增量：=len（ans）/片数
var tmp_val[4]64
var tmp_指数[4]chan int
对于i:=范围tmp_val{
tmp_val[i]=制造（64）
tmp_指数[i]=制造（成交量）
}
对于i，j:=0，0；i
我做禅是错的。我应该做的

numberOfSlices := 4
incr := len(ans)/numberOfSlices
var tmp_val [4]chan float64
var tmp_index [4]chan int

for i := range tmp_val {
    tmp_val[i] = make(chan float64)
    tmp_index[i] = make(chan int)
}

for i,j := 0 , 0; i < len(ans); j++{
    fmt.Printf("From %d to %d [j:%d] - %d\n",i,i+incr,j,len(ans))
    go maximumFunc(ans[i:i+incr],i,tmp_val[j],tmp_index[j])

    i = i+ incr
}

numberOfSlices:=4
增量：=len（ans）/片数
var tmp_val[4]64
var tmp_指数[4]chan int
对于i:=范围tmp_val{
tmp_val[i]=制造（64）
tmp_指数[i]=制造（成交量）
}
对于i，j:=0，0；i
对于那些阅读这个问题并可能想知道为什么他的代码失败的人，这里有一个解释

当他这样构建自己的通道时：

tmp_val := make([]chan float64,numberOfSlices)

他制作了通道切片，其中每个索引都是通道零值。通道零值是零，因为通道是引用类型，零通道在发送时永远阻塞，而零通道中没有任何内容，因此在接收时也将永远阻塞。因此，会出现死锁

当footy更改代码以使用

tmp_val[i] = make(chan float64)

在一个循环中，他构造了非零通道，一切都很好。
对于那些阅读这个问题并可能想知道为什么他的代码失败的人，这里有一个解释

当他这样构建自己的通道时：

tmp_val := make([]chan float64,numberOfSlices)

他制作了通道切片，其中每个索引都是通道零值。通道零值是零，因为通道是引用类型，零通道在发送时永远阻塞，而零通道中没有任何内容，因此在接收时也将永远阻塞。因此，会出现死锁

当footy更改代码以使用

tmp_val[i] = make(chan float64)

在一个循环中，他构建了非零通道，一切都很好