go channel有无缓存的区别

无缓冲的与有缓冲channel有着重大差别,那就是一个是同步的 一个是非同步的。

比如

c1:=make(chan int)         无缓冲

c2:=make(chan int,1)      有缓冲

c1<-1                            

无缓冲: 不仅仅是向 c1 通道放 1,而是一直要等有别的携程 <-c1 接手了这个参数,那么c1<-1才会继续下去,要不然就一直阻塞着。

有缓冲: c2<-1 则不会阻塞,因为缓冲大小是1(其实是缓冲大小为0),只有当放第二个值的时候,第一个还没被人拿走,这时候才会阻塞。


我对以上做一些解释,首先确实得承认channel有缓存与无缓存确实差别巨大,缓存为1和不设置缓存输出有差别。但是上面有缓存的解释是合理的,无缓存的我保留一下意见,用用代码实例来做下分析。

首先看示例1:

  
  
[plain] view plain copy
  1. package main  
  2.   
  3. import (  
  4.     "fmt"  
  5. )  
  6.   
  7. func main() {  
  8.     jobs := make(chan int, 1)  
  9.     done := make(chan bool)  
  10.     go func() {  
  11. //      fmt.Println("GoStart")  
  12.         for i := 1; ; i++ {  
  13. //          fmt.Println("GoforSTART", i)  
  14.             j, more := <-jobs  
  15.             if more {  
  16.                 fmt.Println("received job", j)  
  17.             } else {  
  18.                 fmt.Println("received all jobs")  
  19.                 done <- true  
  20.                 return  
  21.             }  
  22. //          fmt.Println("GoforEND", i)  
  23.         }  
  24.     }()  
  25.     for j := 1; j <= 3; j++ {  
  26. //      fmt.Println("OutFOR", j)  
  27.         jobs <- j  
  28.         fmt.Println("sent job", j)  
  29.     }  
  30.   
  31.     close(jobs)  
  32.     fmt.Println("sent all jobs")  
  33.   
  34.     <-done  
  35. }  

其输出是:
[plain]  view plain  copy
  1. sent job 1  
  2. received job 1  
  3. sent job 2  
  4. received job 2  
  5. sent job 3  
  6. sent all jobs  
  7. received job 3  
  8. received all jobs  
这是有缓存的情况,输出跟大家所预想的是一样的,每次遇到
[plain]  view plain  copy
  1. jobs <- j  
程序会继续向下执行,直到程序循环到下次 jobs <- j,因为jobs的开辟的缓存已满,故程序转而执行goroutine部分,在goroutine中,当程序执行至
[plain]  view plain  copy
  1. j, more := <-jobs  
取出channel中的值,等到goroutine中遇到阻塞,回到外部main()函数继续执行

然后分析看示例2:
将上一段得程序有缓存channel修改为无缓存,即:
[plain]  view plain  copy
  1. jobs := make(chan int, 1)  
修改为
[plain]  view plain  copy
  1. jobs := make(chan int)  
并将代码中的注释部分全部还原执行。

其输出是:
[plain]  view plain  copy
  1. OutFOR 1  
  2. GoStart  
  3. GoforSTART 1  
  4. received job 1  
  5. GoforEND 1  
  6. GoforSTART 2  
  7. sent job 1  
  8. OutFOR 2  
  9. sent job 2  
  10. OutFOR 3  
  11. received job 2  
  12. GoforEND 2  
  13. GoforSTART 3  
  14. received job 3  
  15. GoforEND 3  
  16. GoforSTART 4  
  17. sent job 3  
  18. sent all jobs  
  19. received all jobs  

我们分析:
       当for循环运行至第一次 jobs <- j ,程序直接进入goroutine,由输出的“ GoStart” 紧跟 “OutFOR 1” 得到验证。然后程序执行至在goroutine中for的第二次循环
[plain]  view plain  copy
  1. j, more := <-jobs  
处阻塞,回到外部main()的for循环。
       但外部main的for循环执行第二圈时,并未在 jobs <- j  后进入goroutine,而是继续执行,由
[plain]  view plain  copy
  1. sent job 2  
  2. OutFOR 3  
紧跟
[plain]  view plain  copy
  1. OutFOR 2  
得到验证。
       而外部for进入第三次循环时阻塞,因为jobs中得值还未取出,故而转入goroutine继续执行。


问题出在
[plain]  view plain  copy
  1. jobs <- j  
是继续执行还是阻塞去在其他goroutine中传递值,按照本文开头索引的帖子所指出,应该jobs 通道放j,需要有携程接手这个参数,才可继续执行,但上面得分析看到情况并非如此。


示例3:

[plain]  view plain  copy
  1. package main  
  2.   
  3. import (  
  4.     "fmt"  
  5. )  
  6.   
  7. func main() {  
  8.     jobs := make(chan int)  
  9.     go func() {  
  10.         fmt.Println("Goroutin Start")  
  11.         for {  
  12.             select {  
  13.             case src := <-jobs:  
  14.                 fmt.Println("Get ", src)  
  15.             }  
  16.         }  
  17.     }()  
  18.   
  19.     for j := 0; j < 5; j++ {  
  20.         jobs <- j  
  21.         fmt.Println("Sent job ", j)  
  22.     }  
  23.   
  24.     close(jobs)  
  25.     fmt.Println("finish.")  
  26. }  
其输出为:

[plain]  view plain  copy
  1. Goroutin Start  
  2. Get  0  
  3. Sent job  0  
  4. Sent job  1  
  5. Get  1  
  6. Get  2  
  7. Sent job  2  
  8. Sent job  3  
  9. Get  3  
  10. Get  4  
  11. Sent job  4  
  12. finish.  

当遇到向channel写入值,是否往下执行是交替的,也就是说是随机的。

本文示例环境是go 1.4,本文所做的解释也是因为携程都是利用同一cpu在不同时间片上运行所做的输出分析。

goroutine利用阻塞同步携程之间的数据是非常重要的思想,但大家编程的时候要特别小心。

相关文章

相关标签/搜索