本来觉得自己的golang的channel已经有所了解了,但实际在被问一些问题的时候,还是没法回答的非常明确,所以今天又梳理整理了一遍,并且把容易出错的问题记录一下。
废话不多说,先上一段代码:
package main
import (
"fmt"
)
func Count(ch chan int, n int) {
fmt.Println("Counting ", n)
ch <- n
}
func main() {
chs := make([]chan int, 10)
for i := 0; i < 10; i++ {
chs[i] = make(chan int)
go Count(chs[i], i)
}
for _, ch := range chs {
v := <-ch
fmt.Println("v ", v)
}
}
想一下输出结果应该是什么呢?我承认这个一开始确实自己没有看仔细,chs
是一个信道数组,他的每一个参数都是重新new的一个信道,所以输出结果应该是这样:
Counting 9
Counting 0
v 0
Counting 1
v 1
Counting 6
...
全部会输出,并且顺序不一定
我一开始想,这个信道不是没有缓存吗?应该读一个取一个才对,但是没看到,其实数组里面的每一个参数都是重新new的信道。那什么情况才会是我想象中的输出结果呢?代码可以改成这样,只改main函数就可以:
func main() {
ch := make(chan int)
for i := 0; i < 10; i++ {
go Count(ch, i)
}
for i := 0; i < 10; i++ {
v := <-ch
fmt.Println("v ", v)
}
}
这个时候,就是读一个取一个,因为只有一个信道,输出结果:
Counting 9
v 9
Counting 0
v 0
Counting 1
v 1
Counting 2
v 2
...
这个时候,我想用一个带缓存的信道进行存储,然后用range进行读取,代码就改成了这样:
func Count(ch chan int, n int) {
fmt.Println("Counting ", n)
ch <- n
}
func main() {
ch := make(chan int, 10) //改成有缓存的信道
for i := 0; i < 10; i++ {
go Count(ch, i)
}
for v := range ch {
fmt.Println("v ", v)
}
}
结果输出的时候报错了:
...
Counting 8
v 8
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan receive]:
main.main()
/home/tfd/workspace/go/src/test/main.go:24 +0x126
死锁了,原来是因为range
不会检测信道是否干涸(drained,也就是信道是否已经读取完),在读取完所有数据后,再次读取,会导致main函数挂起。那怎么办呢,第一种方法,如果我知道一共缓存了多少数据,那我就读多少数据就可以了,代码如下:
func main() {
ch := make(chan int, 10)
for i := 0; i < 10; i++ {
go Count(ch, i)
}
for i := 0; i < 10; i++ { //这边假设我知道一共存了10个数据,那就读10次就好了,如果读11次,那就会报deadlock错误
v := <-ch
fmt.Println("v ", v)
}
}
读取结果如下:
Counting 9
v 9
Counting 0
v 0
Counting 1
v 1
Counting 2
v 2
Counting 3
v 3
Counting 7
v 7
Counting 6
v 6
Counting 8
v 8
Counting 4
Counting 5
v 4
v 5
那实际现实中,我很大可能不知道一共写入了多少次,那怎么办呢?我们可以用sync.WaitGroup
, 简单介绍下WaitGroup
对象内部有一个计数器,最初从0开始,它一共包含三个方法:Add()
,Done()
,Wait()
用来控制计数器的数量。Add(n)
把计数器设置为n
,Done()
每次把计数器-1
,Wait()
会阻塞代码的运行,直到计数器的值减为0. 那我们用WaitGroup
改一下代码就可以了。
func Count(ch chan int, n int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Println("Counting ", n)
ch <- n
}
func main() {
//wg := sync.WaitGroup{} //这里可以用new(sync.WaitGroup),这样直接就可以得到指针类型的WaitGroup
wg:= new(sync.WaitGroup)
ch := make(chan int, 10)
for i := 0; i < 10; i++ {
wg.Add(1)
go Count(ch, i, wg)
}
go func() {
wg.Wait()
close(ch)
fmt.Println("Finish")
}()
for v := range ch {
fmt.Println("v:", v)
}
}
这时,代码运行就没问题了,输出结果
Counting 5
Counting 4
v: 5
v: 4
Counting 2
v: 2
Counting 6
Counting 1
v: 6
Counting 0
Counting 8
Counting 3
v: 1
v: 0
v: 8
v: 3
Counting 7
v: 7
Counting 9
Finish
v: 9
但是在这里我也是遇到坑的,一开始WaitGroup
没有传指针,代码是这样的:
func Count(ch chan int, n int, wg sync.WaitGroup) { //wg没有传指针
defer wg.Done()
fmt.Println("Counting ", n)
ch <- n
}
func main() {
wg := sync.WaitGroup{}
ch := make(chan int, 10)
for i := 0; i < 10; i++ {
wg.Add(1)
go Count(ch, i, wg) //wg没有传指针
}
go func() {
wg.Wait()
close(ch)
fmt.Println("Finish")
}()
for v := range ch {
fmt.Println("v:", v)
}
}
这个时候,代码仍然报deadlock,结果我就不贴了。这是因为这个时候wg是将拷贝传递到了goroutine中,所以,wg只有Add操作,而Done操作是在wg的副本中执行的,因此Wait就死锁了。正确的应该是要传指针,上一段代码已经把正确的写进去了。
这里还可以注意一点就是,信道close
了之后可以读但是不可以写,并且,close
之后的信道是不会阻塞的,所以才可以通过WaitGroup
的方法在数据写完之后把信道close
就不会出现阻塞的情况了。
有疑问加站长微信联系(非本文作者)