两个软件包之间的通道通信陷入僵局-Golang

问题描述

两个软件包-Golang之间的通道通信陷入僵局。

我有两个通过两个渠道交流的包裹。一个是主要功能，另一个具有功能。运行它时，会出现死锁。

--omit-link-times

另一个包是

package main

import (
    functionspackage "GoEjemplos/subFolder"
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    ChannelSendData := make(chan functionspackage.FunctionStruct,1)
    defer close(ChannelSendData)

    data := functionspackage.FunctionStruct{
        FieldOne: 3.56,FieldTwo: 23,}

    ChannelSendData <- data

    wg.Add(1)
    go functionspackage.FunctionExt(ChannelSendData,&wg)

    recibe := <-functionspackage.ChannelOutFunct

    fmt.Println("channelOut: ",recibe)

    close(functionspackage.ChannelOutFunct)

    wg.Wait()
}

这是僵局。

package functionspackage

import "sync"

type FunctionStruct struct {
    FieldOne float64
    FieldTwo int
}

var ChannelOutFunct chan float64

func FunctionExt(RecibeChan chan FunctionStruct,wg *sync.WaitGroup) (ChannelOutFunct chan float64) {

    reciveData := <-RecibeChan

    result := reciveData.FieldOne * float64(reciveData.FieldTwo)

    ChannelOutFunct <- result

    wg.Done()

    return ChannelOutFunct
}

您能告诉我问题出在哪里吗

谢谢！

解决方法

通道functionspackage.ChannelOutFunct未初始化，因此它是一个空通道。写入nil通道或从nil通道读取将始终阻塞。

https://dave.cheney.net/2014/03/19/channel-axioms

,

我明白了。这是代码

package main

import (
    packagefunctions "GoEjemplos/subFolder"
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var ChannelSendData = make(chan packagefunctions.FunctionStruct,0)
    defer close(ChannelSendData)
    var ChanReturn = make(chan float64)
    defer close(ChanReturn)

    data := packagefunctions.FunctionStruct{
        FieldOne: 3.56,FieldTwo: 2,}

    wg.Add(1)
    go func() { ChannelSendData <- data }()

    wg.Add(1)
    go func() {
        ChanReturn = packagefunctions.FunctionExt(ChannelSendData,&wg)
        recibeChanReturn := <-ChanReturn
        fmt.Println("channelOut: ",recibeChanReturn)
        wg.Done()
    }()
    wg.Wait()
}

另一个包裹是

package packagefunctions

import (
    "fmt"
    "sync"
)

type FunctionStruct struct {
    FieldOne float64
    FieldTwo int
}

func FunctionExt(ChanIn chan FunctionStruct,wg *sync.WaitGroup) chan float64 {
    reciveData,ok := <-ChanIn
    if ok == false {
        fmt.Println("channel closed")
    }
    var result float64
    result = reciveData.FieldOne * float64(reciveData.FieldTwo)
    var ChannelReturn = make(chan float64,1)
    defer close(ChannelReturn)
    ChannelReturn <- result
    wg.Done()
    return ChannelReturn
}