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利用阻塞同步携程之间的数据是非常重要的思想，但大家编程的时候要特别小心。