详解如何在Golang中监听多个channel
select 关键字
我们可以使用select关键字来同时监听多个goroutine。
package main
import (
"fmt"
"time"
)
func main() {
c1 := make(chan string)
c2 := make(chan string)
go func() {
time.Sleep(1 * time.Second)
c1 <- time.Now().String()
}()
go func() {
time.Sleep(2 * time.Second)
c2 <- time.Now().String()
}()
for i := 0; i < 2; i++ {
select {
case res1 := <-c1:
fmt.Println("from c1:", res1)
case res2 := <-c2:
fmt.Println("from c2:", res2)
}
}
}from c1: 2022-09-04 14:30:39.4469184 -0400 EDT m=+1.000172801
from c2: 2022-09-04 14:30:40.4472699 -0400 EDT m=+2.000524401
上面的代码显示了select关键字是如何工作的：
- 我们首先创建两个 channel c1和c2来监听。
- 然后我们生成两个goroutine，分别向c1和c2发送当前时间。
- 在for循环中，我们创建了一个select语句，并定义了两个 case：第一个 case 是我们何时可以从c1接收，第二个 case 是我们何时可以从c2接收。
你可以看到select语句和switch语句在设计上非常相似。两者都定义了不同的情况，并在满足某种情况时运行相应的代码。另外，我们可以看到select语句是阻塞的。也就是说，它将等待，直到其中一个 case 被满足。
我们为这个循环迭代了两次，因为只有两个goroutine需要监听。更确切地说，每个goroutine都是一个fire-and-forget goroutine，意味着它们在返回之前只向一个通道发送一次。因此，在这段代码中，任何时候都有两个消息的最大值，而我们只需要选择两次。
如果我们不知道工作何时会结束呢
有时我们不知道有多少个工作。在这种情况下，把 select 语句放在一个while循环里。
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
c1 := make(chan string)
rand.Seed(time.Now().UnixNano())
for i := 0; i < rand.Intn(10); i++ {
go func() {
time.Sleep(1 * time.Second)
c1 <- time.Now().String()
}()
}
for {
select {
case res1 := <-c1:
fmt.Println("from c1:", res1)
}
}
}因为我们让一个随机数的goroutines运行，所以我们不知道有多少个作业。值得庆幸的是，底部包裹着select语句的for循环将捕获每一个输出。让我们看看如果我们运行这段代码会发生什么。
from c1: 2022-09-04 14:48:47.5145341 -0400 EDT m=+1.000257801
from c1: 2022-09-04 14:48:47.5146126 -0400 EDT m=+1.000336201
from c1: 2022-09-04 14:48:47.5146364 -0400 EDT m=+1.000359901
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan receive]:
main.main()
/home/jacob/blog/testing/listening-to-multiple-channels-in-go/main.go:22 +0x128
exit status 2
嗯，select 语句按预期收到了三次，但由于死锁，程序出错了。为什么会出现这种情况？
记住，在没有任何条件的情况下，Go中的for循环会永远运行。这意味着 select 语句将永远尝试接收。然而，要运行的作业数量是有限的。即使没有更多的工作，select 语句仍然会尝试接收。
还记得在本系列的第一篇文章中我说过，如果你在发送方没有准备好的时候试图从一个没有缓冲的通道中接收，你的程序就会陷入死锁。这正是我们例子中的情况。
那么我们如何解决这个问题呢？我们可以使用以前文章中涉及的概念的组合：退出通道和WaitGroups。
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
func main() {
c1 := make(chan string)
exit := make(chan struct{})
rand.Seed(time.Now().UnixNano())
var wg sync.WaitGroup
go func() {
numJob := rand.Intn(10)
fmt.Println("number of jobs:", numJob)
for i := 0; i < numJob; i++ {
wg.Add(1)
go func() {
defer wg.Done()
time.Sleep(1 * time.Second)
c1 <- time.Now().String()
}()
}
wg.Wait()
close(exit)
}()
for {
select {
case res1 := <-c1:
fmt.Println("from c1:", res1)
case <-exit:
return
}
}
}3
from c1: 2022-09-04 15:09:08.6936976 -0400 EDT m=+1.000287801
from c1: 2022-09-04 15:09:08.6937788 -0400 EDT m=+1.000369101
from c1: 2022-09-04 15:09:08.6937949 -0400 EDT m=+1.000385101
- 我们创建一个
exit channel和一个WaitGroup。 - 每次运行的作业数都是随机的。对于numJobs的次数，我们启动goroutines。为了等待作业的完成，我们把它们加到wg中。当一个工作完成后，我们从wg中减去一个。
- 一旦所有工作完成，我们就关闭
exit channel。 - 我们将上述部分包裹在一个goroutine中，因为我们希望所有的部分都是无阻塞的。如果我们不把它包在一个goroutine中，wg.Wait()就会等待，直到作业完成。这将阻塞代码，并且不会让底部的for-select语句运行。
- 此外，由于c1是一个未缓冲的通道，等待所有的goroutine将消息发送到c1，将导致许多消息被发送到c1而没有for-select语句接收。这就导致了一个死锁，因为当发送者准备好时，接收者还没有准备好。
如何使select成为非阻塞式的
select语句默认是阻塞的。我们如何使其成为非阻塞的呢？这很简单--我们只需添加一个 default case。
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
func main() {
ashleyMsg := make(chan string)
brianMsg := make(chan string)
exit := make(chan struct{})
rand.Seed(time.Now().UnixNano())
var wg sync.WaitGroup
go func() {
numJob := rand.Intn(10)
fmt.Println("number of jobs:", numJob)
for i := 0; i < numJob; i++ {
wg.Add(2)
go func() {
defer wg.Done()
time.Sleep(time.Duration(rand.Intn(10)) * time.Millisecond)
ashleyMsg <- "hi"
}()
go func() {
defer wg.Done()
time.Sleep(time.Duration(rand.Intn(10)) * time.Millisecond)
brianMsg <- "what's up"
}()
}
wg.Wait()
close(exit)
}()
for {
select {
case res1 := <-ashleyMsg:
fmt.Println("ashley:", res1)
case res2 := <-brianMsg:
fmt.Println("brian:", res2)
case <-exit:
fmt.Println("chat ended")
return
default:
fmt.Println("...")
time.Sleep(time.Millisecond)
}
}
}...
number of jobs: 4
brian: what's up
...
ashley: hi
...
...
brian: what's up
ashley: hi
ashley: hi
brian: what's up
...
...
ashley: hi
...
brian: what's up
...
chat ended
除了蹩脚的对话之外，我们可以看到默认情况下的工作方式。与其等待聊天记录的到来，我们可以在没有频道可以接收的时候做一些事情。在这个例子中，我们只是打印出省略号，但你可以做任何你想做的事情。
到此这篇关于详解如何在Golang中监听多个channel的文章就介绍到这了,更多相关Golang监听多个channel内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
fasthttp 是 Go 的快速 HTTP 实现，当前在 1M 并发的生产环境使用非常成功，可以从单个服务器进行 100K qps 的持续连接，总而言之，fasthttp 比 net/http 快 10 倍，下面通过本文给大家介绍golang fasthttp http请求的相关知识，一起看看吧2021-09-09
这篇文章主要介绍了Golang汇编之控制流，程序执行的流程主要有顺序、分支和循环几种执行流程，本节主要讨论如何将Go语言的控制流比较直观地转译为汇编程序，或者说如何以汇编思维来编写Go语言代码，感兴趣的同学可以参考下文2023-05-05
这篇文章主要介绍了Go语言io包中的discard类型示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2023-07-07
这篇文章主要介绍了解决golang http重定向失效的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2020-12-12
本文主要介绍了Golang动态调用方法小结，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2021-12-12
go mod 安装依赖 unkown revision问题的解决方案
这篇文章主要介绍了go mod 安装依赖 unkown revision问题的解决方案，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2021-05-05
golang使用sync.singleflight解决热点缓存穿透问题
在go的sync包中，有一个singleflight包，里面有一个 singleflight.go文件，代码加注释，一共200行出头，通过 singleflight可以很容易实现缓存和去重的效果，避免重复计算，接下来我们就给大家详细介绍一下sync.singleflight如何解决热点缓存穿透问题2023-07-07
这篇文章主要介绍了GoLang分布式锁与snowflake雪花算法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2022-12-12
这篇文章主要介绍了对Golang中的FORM相关字段理解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2021-05-05
在 Golang 的 Web 项目中,自定义 recovery 中间件是一种常见的做法,用于捕获并处理应用程序的运行时错误,下面我们就来看看具体如何实现吧2023-09-09
最新评论