golang：有缓存channel和无缓存channel的区别

梦里梦外; 2023-07-05 11:48 55阅读 0赞

# `Channel` #

*  通道又叫`channel`，顾名思义，channel的作用就是在多线程之间传递数据的。
 *  channel 是一种特殊的类型。在任何时候，同时只能有一个goroutine访问通道进行发送和获取数据。
 *  通道像一个传送带或者队列，总是遵循先入先出（First In First Out）的规则，保证收发数据的顺序
 *  channel 分为有缓冲和无缓冲两种。

## 创建无缓冲`channel` ##

chreadandwrite :=make(chan int)
    
    chonlyread := make(<-chan int) //创建只读channel
    chonlywrite := make(chan<- int) //创建只写channel

## 创建有缓冲`channel` ##

chreadandwrite :=make(chan int, 1)
    
    chonlyread := make(<-chan int) //创建只读channel
    chonlywrite := make(chan<- int) //创建只写channel

## 两者区别 ##

下面我们来看一个例子：

ch := make(chan int)     
    ch <- 1
    go func() {
        
        <-ch
        fmt.Println("1")
    }()
    fmt.Println("2")

这段代码执行时会出现一个错误：fatal error: all goroutines are asleep - deadlock!

这个错误的意思是说线程陷入了死锁，程序无法继续往下执行。那么造成这种错误的原因是什么呢？

*  我们创建了一个无缓冲的`channel`，然后给这个`channel`赋值了，程序就在赋值后陷入了死锁。
 *  因为我们的`channel`是无缓冲的，即同步的，赋值完成之后来不及读取`channel`，程序就已经阻塞了。
 *  **`channel`的机制是先进先出，如果你给`channel`赋值了，那么必须要读取它的值，不然就会造成阻塞，当然这个只对无缓冲的`channel`有效。对于有缓冲的`channel`，发送方会一直阻塞直到数据被拷贝到缓冲区；如果缓冲区已满，则发送方只能在接收方取走数据后才能从阻塞状态恢复。**

对于上面的例子有两种解决方案：  
1、给channel增加缓冲区，然后在程序的最后让主线程休眠一秒，代码如下：

ch :=make(chan int,1)
    ch <- 1
    go func() {
        
        v := <-ch
        fmt.Println(v)
    }()
    time.Sleep(1 * time.Second)
    fmt.Println("2")

这样的话程序就会依次打印出1、2

2、把ch<-1这一行代码放到子线程代码的后面，代码如下：

ch :=make(chan int)
    
    	go func() {
        
    		v := <-ch
    		fmt.Println(v)
    	}()
    	ch <- 1
    	fmt.Println("2")
    	/*
    	1
    	2
    	*/

这里就不用让主线程休眠了，因为channel在主线程中被赋值后，主线程就会阻塞，直到channel的值在子线程中被取出。

最后我们看一个生产者和消费者的例子：

import (
    
        "fmt"
        "time"
    )
    func produce(p chan<- int) {
        
        for i := 0; i < 10; i++ {
        
            p <- i
            fmt.Println("send:", i)
        }
    }
    func consumer(c <-chan int) {
        
        for i := 0; i < 10; i++ {
        
            v := <-c
            fmt.Println("receive:", v)
        }
    }
    func main() {
        
        ch := make(chan int)
        go produce(ch)
        go consumer(ch)
        time.Sleep(1 * time.Second)
    }

在这段代码中，因为channel是没有缓冲的，所以当生产者给channel赋值后，生产者这个线程会阻塞，直到消费者线程将channel中的数据取出。消费者第一次将数据取出后，进行下一次循环时，消费者的线程也会阻塞，因为生产者还没有将数据存入，这时程序会去执行生产者的线程。程序就这样在消费者和生产者两个线程间不断切换，直到循环结束。  
![在这里插入图片描述][20200214180547159.png]  
下面我们再看一个带缓冲的例子：

func produce(p chan<- int) {
        
        for i := 0; i < 10; i++ {
        
            p <- i
            fmt.Println("send:", i)
        }
    }
    func consumer(c <-chan int) {
        
        for i := 0; i < 10; i++ {
        
            v := <-c
            fmt.Println("receive:", v)
        }
    }
    func main() {
        
        ch := make(chan int, 10)
        go produce(ch)
        go consumer(ch)
        time.Sleep(1 * time.Second)
    }

![在这里插入图片描述][20200214180629536.png]

[20200214180547159.png]: https://img-blog.csdnimg.cn/20200214180547159.png
[20200214180629536.png]: https://img-blog.csdnimg.cn/20200214180629536.png