致命错误：所有 goroutines 都睡着了 - 死锁 | Go例程

Question

问题是 goOne 和 goTwo 函数都分别向通道 ch1 和 ch2 发送值，但是在主 function 中没有这些值的相应接收器。这意味着通道被阻塞，程序无法继续。 导致main function中的select语句无法从通道读取，所以一直执行default case。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    ch1 := make(chan string)
    ch2 := make(chan string)

    wg.Add(2)
    go goOne(&wg, ch1)
    go goTwo(&wg, ch2)

    select {
    case <-ch1:
        fmt.Println(<-ch1)
        close(ch1)

    case <-ch2:
        fmt.Println(<-ch2)
        close(ch2)

    default:
        fmt.Println("Default Case")
    }
    wg.Wait()

}

func goTwo(wg *sync.WaitGroup, ch2 chan string) {
    ch2 <- "Channel 2"
    wg.Done()
}

func goOne(wg *sync.WaitGroup, ch1 chan string) {
    ch1 <- "Channel 1"
    wg.Done()
}

Output：

Default Case
fatal error: all goroutines are asleep - deadlock!

goroutine 1 \[semacquire\]:
sync.runtime_Semacquire(0xc000108270?)
/usr/local/go/src/runtime/sema.go:62 +0x25
sync.(\*WaitGroup).Wait(0x4b9778?)
/usr/local/go/src/sync/waitgroup.go:139 +0x52
main.main()
/home/nidhey/Documents/Go_Learning/goroutines/select.go:29 +0x2af

goroutine 6 \[chan send\]:
main.goOne(0x0?, 0x0?)
/home/nidhey/Documents/Go_Learning/goroutines/select.go:39 +0x28
created by main.main
/home/nidhey/Documents/Go_Learning/goroutines/select.go:14 +0xc5

goroutine 7 \[chan send\]:
main.goTwo(0x0?, 0x0?)
/home/nidhey/Documents/Go_Learning/goroutines/select.go:33 +0x28
created by main.main
/home/nidhey/Documents/Go_Learning/goroutines/select.go:15 +0x119\```

我正在寻找一种不同的模式，例如 select 来处理通道被阻塞的情况。

为了解决这个问题，我在 wg.Wait() 之后的主 function 中添加了 <-ch1 或 <-ch2 以接收发送到通道的值并取消阻止它们

Answer 1

目前还不完全清楚你想做什么。 如果你想等待两个 goroutines 完成他们的工作并将他们的工作结果放入通道，你不需要权重组（因为它不会被达到）。

你可以这样做。

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go goOne(ch1)
    go goTwo(ch2)

    for {
        select {
        case v := <-ch1:
            fmt.Println("Done ch1:", v)
            ch1 = nil
        case v := <-ch2:
            fmt.Println("Done ch2:", v)
            ch2 = nil
        case <-time.After(time.Second):
            fmt.Println("I didn't get result so lets skip it!")
            ch1, ch2 = nil, nil
        }
        if ch1 == nil && ch2 == nil {
            break
        }
    }
}

func goTwo(ch chan string) {
    ch <- "Channel 2"
}

func goOne(_ chan string) {
    //ch1 <- "Channel 1"
}

Answer 2

首先，你有一个竞争条件，因为当你输入 select 语句时，你的频道发布 goroutines 可能还没有启动，它会立即进入默认状态。

但是假设您解决了这个问题（例如，使用另一种形式的信号量），您将进入下一个问题 - 您的 select 语句将获得 chan1 或 chan2 消息，然后在方法的底部等待，但由于它不再在select 声明，您的一条消息不会到达，您将永远等待。

您需要一个循环（在本例中为两次）或一个接收器，用于在各自的 goroutine 中运行的两个通道，以获取这两个消息并完成等待组。

但无论如何 - 正如其他人所质疑的那样 - 你想要达到什么目的？

Answer 3

您可以尝试在单个通道上迭代（假设两个通道返回相同类型的数据），然后在 main 方法中计算完成了多少任务。 然后在所有任务完成后关闭通道。 例子：

package main

import (
    "fmt"
)

func main() {
    ch := make(chan string)

    go goOne(ch)
    go goTwo(ch)
    doneCount := 0

    for v := range ch {
        fmt.Println(v)
        doneCount++
        if doneCount == 2 {
            close(ch)
        }
    }
}

func goTwo(ch chan string) {
    ch <- "Channel 2"
}

func goOne(ch chan string) {
    ch <- "Channel 1"
}