Go并发编程-channel多路复用

在前面两篇文章中,已经详细的介绍了 goroutine 和 channel,它们是 Go 并发编程的基础。今天这篇文章会介绍 Go 并发编程中另一个重要的角色——多路复用。

1. 为什么需要多路复用

Go 程序在并发处理一些任务的时,会为每一个任务创建一个 goroutine,然后需要根据不同的 goroutine 的返回的结果做不同的处理。

如果按照通常的做法,分别获取每个 channel 的结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
taskCh1 := make(chan bool)
taskCh2 := make(chan bool)
taskCh3 := make(chan bool)

go run(taskCh1)
go run(taskCh2)
go run(taskCh3)

for {
// 接收通道 1 的结果
result1 := <-taskCh1
// 接收通道 2 的结果
result2 := <-taskCh2
// 接收通道 3 的结果
result3 := <-taskCh3
}

然后再根据不同 goroutine 返回的结果做后续的处理,这个代码有个问题,需要等待所有的 goroutine 都执行完成之后才能做出结果,这样实现的效率很低,因为每一个获取 channel 值的过程都是阻塞的。

在处理多个通道时,想同时接收多个通道的数据将会变的很困难。

而且在一些情况下,需要根据先返回通道的做出不同的处理,上面那种方式无法做到,这就需要使用多路复用

Go 提供了 select 机制来解决这个问题。

2. select 基本使用

select 语法形式和 switch 很相似,switch 接收一个变量,然后根据变量的值做不同的处理,select 操作接收的是通道操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ch := make(chan int, 1) // 这个例子中,这里必须用缓冲通道

for {
select {
case <-ch:
time.Sleep(time.Second)
fmt.Println("case 1 invoke")
case data := <-ch:
time.Sleep(time.Second)
fmt.Printf("case 2 invoke %d\n", data)
case ch <- 100:
time.Sleep(time.Second)
fmt.Println("case3 invoke")
}

在 select 的 case 中,可以执行三种操作:

  1. <- ch:接收通道,但是对值不处理
  2. data := <-ch:接收通道,并处理从通道中得到的结果
  3. ch <- 100:向通道中发送数据

上面的程序运行起来之后,case 3 会首先执行,然后 case1 和 case2 会随机执行一个,程序就这样一直交替运行下去。

如果用 select 改造上面第一个例子中的代码,就是下面这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
for {
select {
// 接收通道 1 的结果
case r := <-taskCh1:
fmt.Printf("task1 result %+v\n", r)
// 接收通道 2 的结果
case r := <-taskCh2:
fmt.Printf("task2 result %+v\n", r)
// 接收通道 3 的结果
case r := <-taskCh3:
fmt.Printf("task3 result %+v\n", r)
}
}

select 会及时响应每一个就绪的 channel,无论是发送数据还是接收数据。

3. 处理超时情况

select 除了用于同时处理多个通道之外,还可以用来处理一些通道超时的情况,通道在阻塞的时候,如果没有外界的干扰,会一直等下去,但是可以通过 select 设置一个超时时间,来打断阻塞:

1
2
3
4
5
6
7
8
9
ch := make(chan int, 1)

select {
case data := <- ch:
fmt.Printf("case invoke %+v\n", data)
case <-time.After(3 * time.Second):
fmt.Println("channel timeout")

}

上面的代码在创建了一个通道,但没有向通道中发送数据,如果不用 select,程序就会死锁。

select 中添加了两个 case,一个从通道中获取数据, 但肯定获取不到,所以在 3 秒钟之后,另一个 case 就会执行,返回通道超时的提示,这样就避免了程序会一直等待下去。

还有一个情况是我们有时候需用通过键盘获取其他输入设备向程序发送信号,也可以通过这种方式来实现,把上面的程序再修改一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
ch := make(chan int, 1)

quitCh := make(chan bool, 1)

go func(ch chan bool) {
var quit string
fmt.Printf("quit? are you sure?: ")
fmt.Scanln(&quit)
quitCh <- true
}(quitCh)

select {
case data := <- ch:
fmt.Printf("case invoke %+v\n", data)
case <-quitCh:
fmt.Println("program quit")

}

这次不再通过超时来控制,而是通过键盘来控制,新建了一个通道,只有在键盘输入之后,才会向通道中发送数据,这样就可以做到自由控制程序的退出。

4. 非阻塞的 select

在上面的示例代码中,其实还少写了一部分,看下面的代码:

1
2
3
4
5
6
7
8
ch := make(chan int)

for {
select {
case <-ch:
fmt.Println("case invoke")
}
}

上面的代码会出现死锁,因为这个 select 只有一个 case,而这个 case 永远都不会接收到数据,所以 select 本身也被阻塞了,程序无法继续运行,就会造成死锁,对于这种情况,我们设置一个可用的 case,让 select 变成非阻塞,就可以解决这个问题。

1
2
3
4
5
6
7
8
9
10
11
ch := make(chan int)

for {
select {
case <-ch:
fmt.Println("case invoke")
default:
time.Sleep(time.Second)
fmt.Println("default invoke")
}
}

这样,程序就不会死锁,而是不断的执行 default 中的内容。

5. 小结

在这篇文章中,我们介绍了通道的多路复用,并说明了可以用到多路复用的场景。下篇文章中,我们来详细聊一下 Go 是如何实现传统的并发模型。

文 / Rayjun

© 2020 Rayjun    PowerBy Hexo    京ICP备16051220号-1