1. Channel

    单纯地将函数并发执行是没有意义的。函数与函数间需要交换数据才能体现并发执行函数的意义。

    虽然可以使用共享内存进行数据交换，但是共享内存在不同的goroutine中容易发生竞态问题。为了保证数据交换的正确性，必须使用互斥量对内存进行加锁，这种做法势必造成性能问题。

    Go语言的并发模型是CSP（Communicating Sequential Processes），提倡通过通信共享内存而不是通过共享内存而实现通信。

    如果说goroutine是Go程序并发的执行体，channel就是它们之间的连接。channel是可以让一个goroutine发送特定值到另一个goroutine的通信机制。

    Go 语言中的通道（channel）是一种特殊的类型。通道像一个传送带或者队列，总是遵循先入先出（First In First Out）的规则，保证收发数据的顺序。每一个通道都是一个具体类型的导管，也就是声明channel的时候需要为其指定元素类型。

    1.1.2. channel类型

    channel是一种类型，一种引用类型。声明通道类型的格式如下：

    举几个例子：

    2.     var ch2 chan bool  // 声明一个传递布尔型的通道
    3.     var ch3 chan []int // 声明一个传递int切片的通道

    1.1.3. 创建channel

    通道是引用类型，通道类型的空值是nil。

    1. var ch chan int
    2. fmt.Println(ch) // <nil>

    声明的通道后需要使用make函数初始化之后才能使用。

    创建channel的格式如下：

    1.     make(chan 元素类型, [缓冲大小])

    channel的缓冲大小是可选的。

    举几个例子：

    1. ch4 := make(chan int)
    2. ch5 := make(chan bool)
    3. ch6 := make(chan []int)

    通道有发送（send）、接收(receive）和关闭（close）三种操作。

    发送和接收都使用<-符号。

    1. ch := make(chan int)

    发送

    将一个值发送到通道中。

    接收

    从一个通道中接收值。

    1. x := <- ch // 从ch中接收值并赋值给变量x
    2. <-ch       // 从ch中接收值，忽略结果

    关闭

    我们通过调用内置的close函数来关闭通道。

    1.     close(ch)

    关于关闭通道需要注意的事情是，只有在通知接收方goroutine所有的数据都发送完毕的时候才需要关闭通道。通道是可以被垃圾回收机制回收的，它和关闭文件是不一样的，在结束操作之后关闭文件是必须要做的，但关闭通道不是必须的。

    关闭后的通道有以下特点：

    1.     1.对一个关闭的通道再发送值就会导致panic。
    2.     2.对一个关闭的通道进行接收会一直获取值直到通道为空。
    3.     3.对一个关闭的并且没有值的通道执行接收操作会得到对应类型的零值。
    4.     4.关闭一个已经关闭的通道会导致panic。

    1.1.5. 无缓冲的通道

    无缓冲的通道又称为阻塞的通道。我们来看一下下面的代码：

    1. func main() {
    2.     ch := make(chan int)
    3.     ch <- 10
    4.     fmt.Println("发送成功")
    5. }

    上面这段代码能够通过编译，但是执行的时候会出现以下错误：

    1.     fatal error: all goroutines are asleep - deadlock!
    3.     goroutine 1 [chan send]:
    4.     main.main()

    为什么会出现deadlock错误呢？

    因为我们使用ch := make(chan int)创建的是无缓冲的通道，无缓冲的通道只有在有人接收值的时候才能发送值。就像你住的小区没有快递柜和代收点，快递员给你打电话必须要把这个物品送到你的手中，简单来说就是无缓冲的通道必须有接收才能发送。

    上面的代码会阻塞在ch <- 10这一行代码形成死锁，那如何解决这个问题呢？

    一种方法是启用一个goroutine去接收值，例如：

    无缓冲通道上的发送操作会阻塞，直到另一个goroutine在该通道上执行接收操作，这时值才能发送成功，两个goroutine将继续执行。相反，如果接收操作先执行，接收方的goroutine将阻塞，直到另一个goroutine在该通道上发送一个值。

    使用无缓冲通道进行通信将导致发送和接收的goroutine同步化。因此，无缓冲通道也被称为同步通道。

    1.1.6. 有缓冲的通道

    Channel - 图1

    我们可以在使用make函数初始化通道的时候为其指定通道的容量，例如：

    1. func main() {
    2.     ch := make(chan int, 1) // 创建一个容量为1的有缓冲区通道
    3.     ch <- 10
    4.     fmt.Println("发送成功")
    5. }

    只要通道的容量大于零，那么该通道就是有缓冲的通道，通道的容量表示通道中能存放元素的数量。就像你小区的快递柜只有那么个多格子，格子满了就装不下了，就阻塞了，等到别人取走一个快递员就能往里面放一个。

    我们可以使用内置的len函数获取通道内元素的数量，使用cap函数获取通道的容量，虽然我们很少会这么做。

    可以通过内置的close()函数关闭channel（如果你的管道不往里存值或者取值的时候一定记得关闭管道）

    1. package main
    3. import "fmt"
    6.     c := make(chan int)
    7.     go func() {
    8.         for i := 0; i < 5; i++ {
    9.             c <- i
    10.         }
    11.         close(c)
    12.     }()
    13.     for {
    14.         if data, ok := <-c; ok {
    15.             fmt.Println(data)
    16.         } else {
    17.             break
    18.         }
    19.     }
    20.     fmt.Println("main结束")
    21. }

    1.1.8. 如何优雅的从通道循环取值

    当通过通道发送有限的数据时，我们可以通过close函数关闭通道来告知从该通道接收值的goroutine停止等待。当通道被关闭时，往该通道发送值会引发panic，从该通道里接收的值一直都是类型零值。那如何判断一个通道是否被关闭了呢？

    我们来看下面这个例子：

    1. // channel 练习
    2. func main() {
    3.     ch1 := make(chan int)
    4.     ch2 := make(chan int)
    5.     // 开启goroutine将0~100的数发送到ch1中
    6.     go func() {
    7.         for i := 0; i < 100; i++ {
    8.             ch1 <- i
    9.         }
    10.         close(ch1)
    11.     }()
    12.     // 开启goroutine从ch1中接收值，并将该值的平方发送到ch2中
    13.     go func() {
    14.             i, ok := <-ch1 // 通道关闭后再取值ok=false
    15.             if !ok {
    16.                 break
    17.             }
    18.             ch2 <- i * i
    20.         close(ch2)
    21.     }()
    22.     // 在主goroutine中从ch2中接收值打印
    23.     for i := range ch2 { // 通道关闭后会退出for range循环
    24.         fmt.Println(i)
    25.     }
    26. }

    从上面的例子中我们看到有两种方式在接收值的时候判断通道是否被关闭，我们通常使用的是for range的方式。

    1.1.9. 单向通道

    有的时候我们会将通道作为参数在多个任务函数间传递，很多时候我们在不同的任务函数中使用通道都会对其进行限制，比如限制通道在函数中只能发送或只能接收。

    Go语言中提供了单向通道来处理这种情况。例如，我们把上面的例子改造如下：

    1. func counter(out chan<- int) {
    2.     for i := 0; i < 100; i++ {
    3.         out <- i
    4.     }
    5.     close(out)
    6. }
    8. func squarer(out chan<- int, in <-chan int) {
    9.     for i := range in {
    10.         out <- i * i
    11.     }
    12.     close(out)
    13. }
    14. func printer(in <-chan int) {
    15.     for i := range in {
    16.         fmt.Println(i)
    17.     }
    18. }
    20. func main() {
    21.     ch1 := make(chan int)
    22.     ch2 := make(chan int)
    23.     go counter(ch1)
    24.     go squarer(ch2, ch1)
    25.     printer(ch2)
    26. }

    其中，

    1.     2.<-chan int是一个只能接收的通道，可以接收但是不能发送。

    在函数传参及任何赋值操作中将双向通道转换为单向通道是可以的，但反过来是不可以的。

    channel常见的异常总结，如下图：