Go 并发编程-channel 连接一切

在上一篇文章中,我们介绍了 Go 并发编程的基础—goroutine,同时也介绍 goroutine 的几种使用方式,但没有说明 goroutine 之间是如何通信的。

Go 语言中有一句经典的话,不要通过共享内存来通信,而应该通过通信来共享内存。这个原则让 channel 成为了 Go 语言中非常重要的一个组件。

goroutine 之间的通信主要是通过 channel 来完成的,这篇文章中,我们来认识一下 channel,以及channel 的基本使用。

1. 什么是通道(channel)

Go 语言中,并发模式有两种实现方式,一种是传统的通过锁和信号量等手段,来实现对个共享变量(内存)的同步访问,从而实现并发。还有一种通过 goroutine + channel 的组合方式,传递值的方式来实现并发。

goroutine + channel 是对 CSP(Communicating Sequential Process)模式的一种实现。CSP 模式中,有两个核心的概念,process 和 channel,process 对应 groutine,所有的 process 之间的通信通过 channel 来实现。

channel 是可以被单独创建的,可以用来连接任意两个 goroutine,channel 也有自己的数据类型,被称之为通道的元素类型

创建一个通道很简单,比如下面创建了传递 int 值的通道:

1
ch := make(chan int)

chan 表示通道,int 表示通道中传递的元素类型,使用 make 就可以创建一个新的通道。make 返回的结果是通道的引用,当复制这个通道或者把通道作为函数参数的时候,传递的都是引用,这点很重要,需要重点理解一下。这里顺便说一下,channel 是可比较的,也就是说可以通过 == 来比较。

通道有两个操作,一个是发送,一个是接收,都使用 <- 来表示,区别在于发送时,通道在前,接收时通道在后。向一个通道中发送数据:

1
2
x := 5
ch <- x

从通道中接收一个结果,如果不把结果赋值给一个变量,结果就会被抛弃,这样也是合法的:

1
2
x := <-ch
<-ch // 这样也是合法的

一个完整的发送和接收的例子如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

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

go func() {
x := 5
ch <- x
}()

y := <-ch
fmt.Println(y)
}

在使用通道的过程中,可能会出现死锁,具体的原因我们下文再详细说。对于通道来说,还有一个操作,就是关闭通道,对于一个已经关闭的 channel,无法再发送数据,否则会发生 panic,但是可以进行接收操作,下面的程序可以正常运行:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import (
"fmt"
)

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

go func() {
x := 5
ch <- x
close(ch)
}()

y := <-ch
fmt.Println(y)
}

2. 无缓冲通道

上面用来创建通道的 make 其实还有第二个参数,用来指定通道容量。如果不指定这个参数或者指定的参数是 0,那么就表示这个通道是无缓冲通道:

1
2
3
// 下面两种创建方式是等价的
ch := make(chan int)
ch := make(chan int, 0)

在无缓冲通道上的发送操作会阻塞,直到接收端的接收操作完成,然后才会继续执行。在上一篇文章中,我们为了解决主 goroutine 等待子 goroutine 执行完成用的就是这个方法。代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
func goroutine2(isDone chan bool) {
fmt.Println("child goroutine begin...")
time.Sleep(2 * time.Second)
fmt.Println("child goroutine end...")
isDone <- true
}

func main() {
isDone := make(chan bool)
go goroutine2(isDone)
<-isDone
fmt.Println("main goroutine end..")
}

所以对于无缓冲通道来说,不能在同一个 goroutine 中使用,否则会造成死锁。关于死锁的问题,下文再详细讨论。

3. 缓冲通道

在创建缓冲通道时,需要指定通道的容量:

1
ch := make(chan int, 3)

上面的代码创建了容量为 3 的通道,可以直接向通道中发送值,发送的前 3 个操作不会阻塞:

1
2
3
ch <- 1
ch <- 2
ch <- 3

如果在发送的过程中,如果接收端没有接收,那么此时通道就是满的,在发送第 4 个值的时候就会阻塞。

对于缓冲通道,可以使用 cap 方法得到通道的容量,可以使用 len 方法得到当前通道中元素的个数:

1
2
cap(ch) // 获取容量
len(ch) // 获取元素个数

对于一个缓冲通道,在同一个 goroutine 中使用也有造成死锁的风险,所以最好不要在同一个 goroutine 中使用通道。

4. 单向通道

在默认情况下,创建的通道可以发送数据,可以接受数据,但是在一些情况下,我们值需要通道的发送或者接收能力。这个时候,就需要单向通道。

单向通道的表示起来很简单,把 <- 放在 chan 前,表示只接收,放在 chan 后表示只发送:

1
2
sendCh := male(chan<- int) // 表示只发送的通道
recCh := make(<-chan int) // 表示只接收的通道

但实际的使用中,我们不需要去创建这种单向通道,只是在某些情况下,我们把通道转成单向通道就行。比如下面的代码中,在 sendData 方法中,我只需要用到通道的发送能力,所以可以通道改成发送的单向通道,其他人阅读代码的时候,也更能理解:

1
2
3
4
5
6
7
8
9
10
func main() {
ch := make(chan int, 10)
sendData(ch)
}

func sendData(sendCh chan<- int) {
for i := 0;i < 10; i++ {
sendCh <- i
}
}

双向通道可以转成转成单向通道,但反过来却不行。

5. 小结

这篇文章介绍了通道,通道对于 Go 语言来说很重要,是实现高并发的基础,通道为 goroutine 之间提供了一种高效安全的通信方式。但在使用通道的时候需要注意死锁问题。

文 / Rayjun

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