详解golang channel有无缓冲区的区别

Binge108

目录

• 有无缓冲的区别
  
• channel 无缓冲
  
  
  
  • 例1:
    
  • 例2:
    
  
  
• channel 带缓存
  
  
  
  • 例1:
    
  • 例2:一边存，一边取
    
  
  

有无缓冲的区别

形象说明一下无缓冲和有缓冲的区别：
无缓冲是同步的，例如 make(chan int)，就是一个送信人去你家门口送信，你不在家他不走，你一定要接下信，他才会走，无缓冲保证信能到你手上。
有缓冲是异步的，例如 make(chan int, 1)，就是一个送信人去你家仍到你家的信箱，转身就走，除非你的信箱满了，他必须等信箱空下来，有缓冲的保证信能进你家的邮箱。

channel 无缓冲



例1:

1. func main() {
   
2.     ch := make(chan int)
   
3.     ch <- 1 // 报错，因为ch 无缓冲，存一个就必须立即取出来
   
4.     fmt.Println(<- ch)
   
5. }

复制代码

改正：

1. func main() {
   
2.     ch := make(chan int)
   
3.     go tt(ch) // 开一个 goroutine
   
4.     fmt.Println("我先执行1111")
   
5.     fmt.Println(<-ch) // 因为前面开了一个 goroutine， 这一行比 go tt(ch) 先执行，这里堵塞了，等到 tt(ch) 中的语句执行完之后，本行执行
   
6.     // 我先执行1111
   
7.     // 我先执行2222
   
8.     // 1
   
9. }
   
10. 
    
11. func tt(ch chan int) {
    
12.     fmt.Println("我先执行2222")
    
13.     ch <- 1
    
14. }

复制代码

例2:

1. package main
   
2. 
   
3. import "fmt"
   
4. 
   
5. func main() {
   
6.     ch := make(chan int) // 无缓冲的channel
   
7.     go unbufferChan(ch)
   
8. 
   
9.     for i := 0; i < 10; i++ {
   
10.         fmt.Println("receive ", <-ch) // 读出值
    
11.     }
    
12. }
    
13. 
    
14. func unbufferChan(ch chan int) {
    
15.     for i := 0; i < 10; i++ {
    
16.         fmt.Println("send ", i)
    
17.         ch <- i // 写入值
    
18.     }
    
19. }
    
20. 
    
21. // 输出
    
22. // send  0
    
23. // send  1
    
24. // receive  0
    
25. // receive  1
    
26. // send  2
    
27. // send  3
    
28. // receive  2
    
29. // receive  3
    
30. // send  4
    
31. // send  5
    
32. // receive  4
    
33. // receive  5
    
34. // send  6
    
35. // send  7
    
36. // receive  6
    
37. // receive  7
    
38. // send  8
    
39. // send  9
    
40. // receive  8
    
41. // receive  9

复制代码

channel 带缓存

例1:

放的速度较快，先放满了 5 个，阻塞住；取的速度较慢，放了5个才开始取，由于缓冲区已经满了，所以取出一个之后，才能再次放入；放完了之后虽然缓冲区关闭了，但是缓冲区的内容还保留，所以还能继续取出

1. func put(c chan int) {
   
2.     for i := 0; i < 10; i++ {
   
3.        c <- i
   
4.        time.Sleep(100 * time.Millisecond)
   
5.        fmt.Println("->放入", i)
   
6.     }
   
7.     fmt.Println("=所有的都放进去了！关闭缓冲区，但是里面的数据不会丢失，还能取出。")
   
8.     close(c)
   
9. }
   
10. 
    
11. func main() {
    
12.     ch := make(chan int, 5)
    
13.     go put(ch)
    
14.     for {
    
15.        time.Sleep(1000 * time.Millisecond)
    
16.        data, ok := <-ch
    
17.        if ok == true {
    
18.           fmt.Println("<-取出", data)
    
19.        } else {
    
20.           break
    
21.        }
    
22.     }
    
23. }
    
24. 
    
25. // ->放入 0
    
26. // ->放入 1
    
27. // ->放入 2
    
28. // ->放入 3
    
29. // ->放入 4
    
30. // <-取出 0
    
31. // ->放入 5
    
32. // <-取出 1
    
33. // ->放入 6
    
34. // <-取出 2
    
35. // ->放入 7
    
36. // <-取出 3
    
37. // ->放入 8
    
38. // <-取出 4
    
39. // ->放入 9
    
40. // =所有的都放进去了！关闭缓冲区，但是里面的数据不会丢失，还能取出。
    
41. // <-取出 5
    
42. // <-取出 6
    
43. // <-取出 7
    
44. // <-取出 8
    
45. // <-取出 9

复制代码

例2:一边存，一边取

1. package main
   
2. 
   
3. import"fmt"
   
4. 
   
5. var c = make(chan int, 5)
   
6. 
   
7. func main() {
   
8.     go worker(1)
   
9.     for i := 1; i < 10; i++ {
   
10.        c <- i
    
11.        fmt.Println(i)
    
12.        fmt.Println("cap = ", cap(c), " len = ", len(c))
    
13.     }
    
14. }
    
15. 
    
16. func worker(id int) {
    
17.     for {
    
18.        _ = <-c
    
19.     }
    
20. }
    
21. 
    
22. // 运行输出：
    
23. // 1
    
24. // cap =  5  len =  0
    
25. // 2
    
26. // cap =  5  len =  0
    
27. // 3
    
28. // cap =  5  len =  1
    
29. // 4
    
30. // cap =  5  len =  2
    
31. // 5
    
32. // cap =  5  len =  0
    
33. // 6
    
34. // cap =  5  len =  1
    
35. // 7
    
36. // cap =  5  len =  2
    
37. // 8
    
38. // cap =  5  len =  2
    
39. // 9
    
40. // cap =  5  len =  0

复制代码

到此这篇关于详解golang channel有无缓冲区的区别的文章就介绍到这了,更多相关golang channel缓冲区内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

布莱德马斯特牙

感谢楼主，顶。