在 Go 语言中,“通道(Channel)” 是连接不同协程的通信管道。当多个协程同时运行时,我们可以通过通道把数据从一个协程传给另一个协程,也可以利用它让主协程准确等待子协程执行完毕。
Go 语言在并发设计上有一句广为人知的理念:“不要通过共享内存来通信,而要通过通信来共享内存。” 简单来说,与其让几个协程同时去抢同一张草稿纸写字,不如把数据放进通道里直接递给对方,这样天然就不容易发生读写冲突。
根据内部是否带有缓冲空间,通道一般分为 2 种:一种是 “无缓冲通道”,另一种是 “有缓冲通道”。
通道的创建与读写语法
在 Go 语言中,通道类型使用关键字 chan 来表示,它是英文 “channel(通道)” 的缩写。每一个通道都只能传递同一种类型的数据,比如 chan int 表示传递整数的通道,chan string 表示传递字符串的通道。
通道和切片一样属于引用类型。在使用之前,我们需要先调用内置的 make() 函数完成初始化,然后再配合左箭头运算符 <- 发送或接收数据。
语法:
// 创建通道
通道名 := make(chan 元素类型)
// 发送数据
通道名 <- 值
// 接收数据
变量名 := <-通道名说明:
对于通道的发送和接收操作,我们需要掌握以下 3 种常用写法:
- ch <- v:向通道发送数据,表示把右侧的值
v放进左侧的通道ch中。 - v := <-ch:从通道接收并保存数据,表示从通道
ch中取出一个值并赋给变量v。 - <-ch:仅接收数据但不保存,表示从通道
ch中取出一个值后直接丢弃,常用于等待完成信号。
提示: 很多初学的小伙伴容易把发送和接收的箭头方向搞混。其实只需要记住一个规律:箭头 <- 永远是向左指的。像 ch <- 10 这样箭头指着通道 ch,就是往通道里塞数据;像 x := <-ch 这样箭头从通道 ch 指出来,就是从通道里往外取数据。
无缓冲通道
在使用 make(chan 元素类型) 创建通道时,如果我们不传入第 2 个容量参数,创建出来的就是 “无缓冲通道”,也叫做 “同步通道”。
无缓冲通道内部没有暂存数据的空间,容量为 0。它就像当面交接物品:如果发送方先到了,就必须停在原地等接收方来接;反过来,如果接收方先到了,也必须停在原地等发送方把数据送过来。只有当双方同时准备就绪,数据才能完成交接,随后两个协程各自继续往下执行。
示例 1:无缓冲通道收发数据
package main
import "fmt"
func main() {
ch := make(chan int) // 创建无缓冲通道
go func() {
fmt.Println("子协程:准备发送数据 100")
ch <- 100 // 向通道发送数据
}()
num := <-ch // 从通道接收数据
fmt.Println("主协程:收到数据", num)
}运行结果如下。
子协程:准备发送数据 100
主协程:收到数据 100分析:
在这个例子中,我们并没有调用 time.Sleep() 函数,为什么 main() 主协程没有提前退出呢?
这是因为当主协程执行到 num := <-ch 时,如果子协程还没有把数据发过来,主协程就会自动停在这一行阻塞等待。直到子协程执行 ch <- 100 把数据送入通道,主协程拿到 100 并赋给 num 后,才会继续往下打印结果并结束程序。
利用无缓冲通道自动阻塞等待的特点,哪怕我们不需要子协程返回具体的计算结果,也可以用它来传递 “完成信号”。下面我们来看一个例子。
示例 2:使用通道等待协程结束
package main
import (
"fmt"
"time"
)
func backupData(done chan bool) {
fmt.Println("备份任务:正在备份数据...")
time.Sleep(100 * time.Millisecond)
fmt.Println("备份任务:数据备份完毕")
done <- true // 发送完成信号
}
func main() {
done := make(chan bool)
go backupData(done)
<-done // 等待子协程发送信号
fmt.Println("主协程:收到完成信号,程序退出")
}运行结果如下。
备份任务:正在备份数据...
备份任务:数据备份完毕
主协程:收到完成信号,程序退出分析:
<-done 表示从 done 通道中接收一个值,但不保存到任何变量中。主协程执行到 <-done 时会一直停在原地等待,直到 backupData() 子协程备份完数据并执行 done <- true,主协程收到信号后才会继续往下退出。
有缓冲通道
无缓冲通道要求每次发送时都必须有另一个协程同时接收,有时不够灵活。如果我们希望发送方在暂时无人接收时,也能先把几条数据存进管道里,就可以使用 “有缓冲通道”,也叫做 “异步通道”。
有缓冲通道就像门口带固定格子的快递柜:只要柜子还没塞满,发送方把数据放进去就能直接往下走;只要柜子里还有数据,接收方随时都能直接取走。

语法:
通道名 := make(chan 元素类型, 缓冲容量)说明:
其中,第 2 个参数是大于 0 的整数,表示通道内部最多可以暂存多少个元素。我们可以使用内置函数 len(ch) 查看通道内当前暂存的元素个数,使用 cap(ch) 查看通道的总缓冲容量。
示例 3:查看缓冲通道的长度与容量
package main
import "fmt"
func main() {
ch := make(chan string, 2) // 创建容量为 2 的通道
ch <- "Hello"
ch <- "lvye"
fmt.Printf("元素个数:%d,总容量:%d\n", len(ch), cap(ch))
fmt.Println(<-ch)
fmt.Println(<-ch)
}运行结果如下。
元素个数:2,总容量:2
Hello
lvye分析:
make(chan string, 2) 表示创建一个容量为 2 的字符串通道。因为内部有 2 个缓冲空位,我们在 main() 函数里连续执行两次发送操作时程序不会卡住,而是直接把 "Hello" 和 "lvye" 暂存进了缓冲区。
随后连续执行两次 <-ch 时,通道会按照 “先进先出” 的顺序,依次取出 "Hello" 和 "lvye"。
如果在多协程场景下,发送方连续发出的数据超过了缓冲容量,又会发生什么呢?下面我们再来看一个例子。
示例 4:有缓冲通道的异步收发
package main
import (
"fmt"
"time"
)
func main() {
ch := make(chan int, 2) // 缓冲容量为 2
go func() {
for i := 1; i <= 3; i++ {
ch <- i
fmt.Printf("发送方:已放入任务 %d\n", i)
}
}()
time.Sleep(100 * time.Millisecond) // 模拟接收方稍晚开始取数据
for i := 1; i <= 3; i++ {
fmt.Printf("接收方:取出任务 %d\n", <-ch)
}
}运行结果如下。
发送方:已放入任务 1
发送方:已放入任务 2
接收方:取出任务 1
发送方:已放入任务 3
接收方:取出任务 2
接收方:取出任务 3分析:
在这个例子中,主协程故意晚 100 毫秒才开始取数据。由于通道 ch 的缓冲容量是 2,发送方不需要等主协程,直接就能把任务 1 和任务 2 放进通道。
当发送方尝试放入第 3 个任务时,缓冲区已经满了,因此它会停在 ch <- 3 这一行等待。等到 100 毫秒后主协程取走任务 1 腾出一个空位,发送方才顺利把任务 3 放进去。
总结来看,这两种通道在阻塞时机上的区别主要有以下 2 点。
- 无缓冲通道:通过
make(chan T)创建,容量为 0。发送时必须有接收方同时就绪,否则立即阻塞;接收时也必须有发送方同时就绪,否则立即阻塞。 - 有缓冲通道:通过
make(chan T, cap)创建,容量大于 0。只有当缓冲区已满时,继续发送才会阻塞;只有当缓冲区里没有数据时,继续接收才会阻塞。
通道死锁(deadlock)
在使用通道编写并发代码时,小伙伴们经常会碰到 “死锁(deadlock)” 报错。所谓的 “死锁”,说白了就是程序中的所有协程都在互相等待对方先行动,结果谁也走不动了。一旦 Go 运行时检测到所有协程都陷入永久等待状态,就会直接终止程序并报 deadlock 错误。
初学者最容易触发死锁的情况,就是在同一个协程里直接对无缓冲通道进行读写。我们来看一个简单例子就懂了。
示例 5:无缓冲通道引发死锁
package main
import "fmt"
func main() {
ch := make(chan int)
ch <- 10 // 无人接收导致卡死
fmt.Println(<-ch)
}运行结果如下。
(报错)fatal error: all goroutines are asleep - deadlock!分析:
从运行结果可以看出,程序直接报出了 all goroutines are asleep - deadlock! 错误,意思是所有协程都已休眠并发生了死锁。为什么下一行明明写了 <-ch 接收,程序还是在 ch <- 10 处卡死了呢?
这是因为 ch 是容量为 0 的无缓冲通道,要求发送的同时必须有另一个协程在旁边接收。而上面代码中只有 main() 这一个主协程,它执行到 ch <- 10 时就会停在原地一直等别人来接,根本没有机会往下走到 fmt.Println(<-ch) 那一行。
同理,如果我们在同一个协程里往容量为 2 的有缓冲通道连塞 3 个数据,也会因为缓冲区已满且无人取走而触发同样的死锁报错。要想解决这个死锁问题,我们只需要像示例 1 那样启动一个子协程去配合收发,或者将 ch 改为带足够容量的有缓冲通道就可以了。
注意: 声明通道时,如果我们只写了 var ch chan int 而没有调用 make() 初始化,此时 ch 的默认值是 nil,这种未初始化的通道称为 “空通道”。对 nil 空通道发送或接收数据都会永久阻塞,同样会直接触发 deadlock 死锁错误。
单向通道(了解)
默认情况下,我们使用 make(chan T) 创建出来的都是既能发送又能接收的 “双向通道”。在实际阅读开源项目或标准库代码时,小伙伴们偶尔还会在函数形参或返回值中看到 “单向通道” 类型,它用来在编译阶段限制通道的读写权限,具体分为以下 2 种:
- chan<- T(只写通道):箭头
<-指着chan,表示在函数内部只允许向通道发送数据,不允许从中接收数据。 - <-chan T(只读通道):箭头
<-从chan指出来,表示在函数内部只允许从通道接收数据,不允许往里面发送数据。
在调用函数时,我们可以直接把普通的双向通道传给单向通道形参,Go 会自动完成类型转换,防止在函数内部误读或误写数据。下面我们通过一个例子来看看单向通道的配对用法。
示例 6:使用单向通道收发数据
package main
import "fmt"
// out 限制为只写通道
func sendData(out chan<- int) {
out <- 100
}
// in 限制为只读通道
func readData(in <-chan int) {
num := <-in
fmt.Printf("收到数据:%d\n", num)
}
func main() {
ch := make(chan int) // 创建双向通道
go sendData(ch) // 自动转为只写通道
readData(ch) // 自动转为只读通道
}运行结果如下。
收到数据:100分析:
在这个例子中,main() 函数创建的 ch 本身是双向通道。当把它传给 sendData(ch) 时,形参 out 会将其限制为只写通道;传给 readData(ch) 时,形参 in 则将其限制为只读通道。
如果我们在 readData() 函数内部误写了 in <- 200 尝试发送数据,编译器就会在编译阶段直接报错。单向通道主要用于大型项目中的函数接口约束,初学阶段小伙伴们简单认个脸熟即可。
