如何修复2个通道互相死锁

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《如何修复2个通道互相死锁》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

我有这段go代码。我需要具备这种能力：在一个地方写入通道，然后在另一个地方读出它们（反之亦然）：

package main
import "fmt"
var ch1=make(chan int)
var ch2=make(chan int)

func f1() {
    select {
    case <- ch1:fmt.println("ch1")
    default: fmt.println("default")
    }
}
func f2() {
    select {
    case <- ch2:fmt.println("ch2")
    default: fmt.println("default")
    }
}
func main() {
    go f1()
    go f2()
    ch1<-1
    ch2<-2
}

它总是像这样打印：

default
ch1
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
    /tmp/sandbox970110849/prog.go:22 +0xa0

我还尝试了这个：

package main
import (
    "fmt"
    "sync"
)
var ch1=make(chan int)
var ch2=make(chan int)

func f1() {
    select {
    case <- ch1:fmt.println("ch1")
    default: fmt.println("default")
    }
}
func f2() {
    select {
    case <- ch2:fmt.println("ch2")
    default: fmt.println("default")
    }
}

func w1() {
    ch1 <-1
}

func w2() {
    ch2 <-1
}
func main() {
    var wg sync.waitgroup
    wg.add(4)
    go f1()
    go f2()
    go w1()
    go w2()
    wg.wait()
}

这次错误更多：

default
ch2
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [semacquire]:
sync.runtime_Semacquire(0x40e028, 0x0)
    /usr/local/go/src/runtime/sema.go:56 +0x40
sync.(*WaitGroup).Wait(0x40e020, 0x14b720)
    /usr/local/go/src/sync/waitgroup.go:130 +0x60
main.main()
    /tmp/sandbox916639182/prog.go:36 +0x100

goroutine 8 [chan send]:
main.w1()
    /tmp/sandbox916639182/prog.go:23 +0x40
created by main.main
    /tmp/sandbox916639182/prog.go:34 +0xc0

我哪里出错了，如何解决？

解决方案

您的 main() 函数尝试在所有通道上发送，并且仅一次性尝试在单独的并发 goroutine 中从这些通道中读取数据。这是否成功取决于 goroutine 调度程序。如果 f2() 中的非阻塞接收安排得早于 main() 中的发送，则 main() 中稍后的发送将永远阻塞（没有人会再次尝试从 ch2 接收）。

摆脱死锁的一种方法是使用接收操作而不是非阻塞接收（在 Go Playground 上尝试一下）：

func f1() {
    <-ch1
    fmt.println("ch1")
}
func f2() {
    <-ch2
    fmt.println("ch2")
}

因此，无论 main() 何时到达在这些通道上发送值的点，总会有一个接收器准备好继续，因此 main() 不会卡住。

请注意，当 main() 返回时，应用程序结束，它不会等待非主 goroutine 完成。因此，您可能不会在控制台上看到 ch1 和 ch2 打印。详情请见No output from goroutine in Go。

如果您的目的是在您的应用程序存在之前等待所有 goroutine 完成其工作，请使用 sync.waitgroup （在 Go Playground 上尝试）：

var ch1 = make(chan int)
var ch2 = make(chan int)

var wg sync.waitgroup

func f1() {
    defer wg.done()
    <-ch1
    fmt.println("ch1")
}

func f2() {
    defer wg.done()
    <-ch2
    fmt.println("ch2")
}

func main() {
    wg.add(1)
    go f1()
    wg.add(1)
    go f2()

    ch1 <- 1
    ch2 <- 2
    wg.wait()
}

在此处查看更多示例：Solving goroutines deadlock；和Prevent the main() function from terminating before goroutines finish in Golang。

另一种选择是为通道提供 1 的缓冲区，因此 main() 可以在通道上发送 1 个值，而无需接收器准备好从通道接收数据（在 Go Playground 上尝试此操作）：

var ch1 = make(chan int, 1)
var ch2 = make(chan int, 1)

有了这个，main() 可以在没有 f1() 和 f2() 的情况下继续，所以同样，不能保证您会看到任何打印内容。

• 当主协程启动时，它会创建两个新的协程 f1 和 f2。
• 当执行 f1 或 f2 时，它将检查通道中是否有值，否则它将打印默认消息并退出。
• 在理想情况下，通道将首先发布值，然后通过 goroutine 接收
• 实际情况是 goroutine 通过打印默认情况退出，但主 goroutine 试图在通道中发布值，但由于没有接收者，因此面临死锁情况。

但是，如果主例程退出，所有关联的 goroutine 将被自动杀死。 这就是为什么我们可以看到该值是任意打印的。

sync.waitgroup 正在使主 goroutine 等待，这就是为什么我们可以在每次程序执行时观察到输出。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。