【GO】并发编程基础-channel

协程（Goroutine）

Go 语言中没有线程的概念，只有协程，也称为 goroutine。相比线程来说，协程更加轻量，一个程序可以随意启动成千上万个 goroutine。

goroutine 被 Go runtime 所调度，这一点和线程不一样。也就是说，Go 语言的并发是由 Go 自己所调度的，自己决定同时执行多少个 goroutine，什么时候执行哪几个。这些对于我们开发者来说完全透明，只需要在编码的时候告诉 Go 语言要启动几个 goroutine，至于如何调度执行，我们不用关心。

要启动一个 goroutine 非常简单，Go 语言为我们提供了 go 关键字，相比其他编程语言简化了很多，如下面的代码所示：

func main() {
   go func() {
       fmt.Print("我是新创建的协程")
   }()
}

go 关键字后跟一个方法或者函数的调用，就可以启动一个 goroutine

协程之间通信（channel）

Go 语言提供的 channel（通道）来解决这个问题

声明一个 channel

ch:=make(chan string)

其中 chan 是一个关键字，表示是 channel 类型。
后面的 string 表示 channel 里的数据是 string 类型。

通过 channel 的声明也可以看到，chan 是一个集合类型。

定义好 chan 后就可以使用了，一个 chan 的操作只有两种：发送和接收。

1. 接收：获取 chan 中的值，操作符为 <- chan。
2. 发送：向 chan 发送值，把值放在 chan 中，操作符为 chan <-。

注意：这里注意发送和接收的操作符，都是 <- ，只不过位置不同。接收的 <- 操作符在 chan 的左侧，发送的 <- 操作符在 chan 的右侧。

使用实例1：无缓冲channel（同步channel）

如果发送方一直没有发送数据，则接收方会一直阻塞，使用 make 创建的 chan 就是一个无缓冲 channel，它的容量是 0，不能存储任何数据。所以无缓冲 channel 只起到传输数据的作用，数据并不会在 channel 中做任何停留。这也意味着，无缓冲 channel 的发送和接收操作是同时进行的，它也可以称为同步 channel。

func TestChannelWithNoBuffer(t *testing.T) {
   ch := make(chan int)
   go func() {
      ch <- 1
   }()
   t.Log("我是main gorountie")
   go func() {
      v := <-ch
      t.Log("获得数据", v)
   }()
}

使用实例2：有缓冲channel

有缓冲 channel 类似一个可阻塞的队列，内部的元素先进先出。通过 make 函数的第二个参数可以指定 channel 容量的大小，进而创建一个有缓冲 channel，如下面的代码所示：

cacheCh:=make(chan int,5)

创建了一个容量为 5 的 channel，内部的元素类型是 int，也就是说这个 channel 内部最多可以存放 5 个类型为 int 的元素

一个有缓冲 channel 具备以下特点：

1. 有缓冲 channel 的内部有一个缓冲队列；
2. 发送操作是向队列的尾部插入元素，如果队列已满，则阻塞等待，直到另一个 goroutine 执行，接收操作释放队列的空间；
3. 接收操作是从队列的头部获取元素并把它从队列中删除，如果队列为空，则阻塞等待，直到另一个 goroutine 执行，发送操作插入新的元素。

func TestChannelWithBuffer(t *testing.T) {
   ch := make(chan string, 10)
   go func() {
      fmt.Println("balabala")
      ch <- "goroutine 完成"
   }()
   fmt.Println("我是main goroutine")
   ch <- "main goroutine 输入的值"
   v := <-ch
   fmt.Println("等待，接收到channel中的值：", v)
}

关闭 channel

channel 还可以使用内置函数 close 关闭

close(cacheCh)

如果一个 channel 被关闭了，就不能向里面发送数据了，如果发送的话，会引起 painc 异常。但是还可以接收 channel 里的数据，如果 channel 里没有数据的话，接收的数据是元素类型的零值。

多路复用：select+channel

func TestSelectChannel(t *testing.T) {
   fir := make(chan int)
   sec := make(chan int)
   tir := make(chan int)
   go func() {
      fir <- 1
   }()
   go func() {
      sec <- 2
   }()
   go func() {
      tir <- 3
   }()
   select {
     case filePath := <-fir:
        t.Log(filePath)
     case filePath := <-sec:
        t.Log(filePath)
     case filePath := <-tir:
        t.Log(filePath)
   }
}

整体结构和 switch 非常像，都有 case 和 default，只不过 select 的 case 是一个个可以操作的 channel。多路复用可以简单地理解为，N 个 channel 中，任意一个 channel 有数据产生，select 都可以监听到，然后执行相应的分支，接收数据并处理。
在 Go 语言中，提倡通过通信来共享内存，而不是通过共享内存来通信，其实就是提倡通过 channel 发送接收消息的方式进行数据传递，而不是通过修改同一个变量。所以在数据流动、传递的场景中要优先使用 channel，它是并发安全的，性能也不错。