到这里你正在接触最核心和重要的知识！认真学习的你很棒！
本节源码位置 https://github.com/golang-minibear2333/golang/blob/master/4.concurrent/channel.go
什么是 channel
Go 是一门从语言级别就支持并发的编程语言， 它有一个设计哲学很特别 不要通过共享内存来通信，而应通过通信来共享内存 ，听起来是有一点绕。
在传统语言中并发使用全局变量来进行不同线程之间的数据共享，这种方式就是使用共享内存的方式进行通信。而 Go 会在协程和协程之间打一个隧道，通过这个隧道来传输数据（发送和接收）。
打个比方，我们平时肯定没少接触过队列，队列的特点是先进先出，多方生产插入，多方消费接收。这个队列/隧道就是channel。
channel 是 goroutine 之间互相通讯的东西，goroutine 之间用来发消息和接收消息。其实，就是在做 goroutine 之间的内存共享。
我们来看看具体是什么使用的。
声明与初始化
channel是类型相关的，也就是说一个 channel 只能传递一种类型的值，这个类型需要在 channel 声明时指定。
channel 的一般声明形式：
var chanName chan 类型
与普通变量的声明不同的是在类型前面加了 channel 关键字，类型 则指定了这个 channel 所能传递的元素类型。示例：
var a chan int //声明一个传递元素类型为int的channel var b chan float64 var c chan strin
通道是一个引用类型，初始值为nil，对于值为nil的通道，不论具体是什么类型，它们所属的接收和发送操作都会永久处于阻塞状态。
所以必须手动make初始化，示例：
a := make(chan int) //初始化一个int型的名为a的channel b := make(chan float64) c := make(chan string)
既然是队列，那就有大小，上面没声明具体的大小，被认为是无缓冲的（注意大小是 0，不是 1）也就是说必须有其他goroutine接收，不然就会阻塞在那。声明有缓冲的，指定大小就可以了。
a := make(chan int,100)
如何使用
我们进一步体验一下无缓冲 channel 会发生什么问题，同时熟悉下用法，示例：
func pendingForever() { a := make(chan int) a <- 1 //将数据写入channel z := <-a //从channel中读取数据 fmt.Println(z) }
观察上面三行代码，第 2 行往 channel 内写入了数据，第 3 行从 channel 中读取了数据
但是这是在同一个方法中，并且没有使用 Go 关键字，说明他们在同一个协程
我们说过 channel 是用来给不同 goroutine 通信的，所以是不能在同一个协程又发送又接收，这根本就达不到隧道通信的效果。所以上面的代码，会死锁：
fatal error: all goroutines are asleep - deadlock! goroutine 1 [chan send]: main.main() .../4.concurrent/channel.go:7 +0x59
死锁的原因是没有其他协程来接收数据，隧道因为是无缓冲的，所以直接永远的阻塞在发送方。
要解决这个问题也好办。放到不同 goroutine 里就可以。
func normal() { chanInt := make(chan int) go func() { chanInt <- 1 }() res := <-chanInt fmt.Println(res) }
输出1。无缓冲通道在无数据发送时，接收端会阻塞，直到有新数据发送过来为止。
上面的代码，一个发送一个接收，而实际使用中数据往往是连续不断发送的。来看一段代码：
func standard() { chanInt := make(chan int) go func() { defer close(chanInt) var produceData = []int{1, 2, 3} for _, v := range produceData { chanInt <- v } }() for v := range chanInt { fmt.Println(v) } }
输出
1 2 3
循环传递数据，父协程循环接收。
range chan 的方式可以不断的接收数据，直到通道关闭，假如通道不关闭会永远阻塞，无法通过编译，直接报死锁。
必须在发送端关闭通道，因为接收端无法预料是否还有数据没有接收完；向已关闭的channel发送数据会panic。
建议使用 defer 来关闭通道，防止程序异常时未正常关闭。
至此我们完成了一个简单的生产者消费者模型。
channel 的关闭
使用 Go 语言内置的 close() 函数即可关闭 channel，再强调一次建议使用defer关闭，示例：
defer close(ch)
关闭了 channel 后如何查看 channel 是否关闭成功了呢？很简单，我们可以在读取 channel 时采用多重返回值的方式，示例：
x, ok := <-ch
通过查看第二个返回值的 bool 值即可判断 channel 是否关闭，若为 false 则表示 channel 被关闭，反之则没有关闭（使用频率不高，了解即可）
func main() { var chanInt chan int = make(chan int, 10) go func() { defer fmt.Println("chanInt is closed") defer close(chanInt) chanInt <- 1 }() res := <-chanInt fmt.Println(res) }
输出
chanInt is closed 1
如上声明了一个有缓冲的通道，在缓冲大小允许的范围内不需要阻塞等待接收
发送端发送完毕后主动关闭通道
虽然通道已经关闭，接收端依然可以接收，接收完自行结束。
PS1: 同一个通道只能关闭一次，重复关闭会panic。
PS2: 如果传入nil,如 close(nil) 会 panic。
多发送、多接收与单向通道
我们结合前面知识，来实战练习一下！
功能：实现一个多发送，多接收的例子。
func send(c chan<- int, wg *sync.WaitGroup) { c <- rand.Int() wg.Done() }
- 发送端随机生成数字，并声明一个仅发送的单向通道
- 使用
sync.WaitGroup做等待（忘记的回顾上一节哈！）
func received(c <-chan int, wg *sync.WaitGroup) { for gotData := range c { fmt.Println(gotData) } wg.Done() }
- 接收端使用
range来接收数字并打印
func main() { chanInt := make(chan int, 10) done := make(chan struct{}) defer close(done) go func() { defer close(chanInt) // 发送 }() go func() { ... // 接收 done <- struct{}{} }() <-done }
- 使用了两个通道，一个通道
chanInt进行数据传输，另一个done控制完毕时结束主协程 - 发送端负责生产数据，生产完毕后关闭通道
- 接收端负责接收完毕后通知主协程
发送端
go func() { var wg sync.WaitGroup defer close(chanInt) for i := 0; i < 5; i++ { wg.Add(1) go send(chanInt, &wg) } wg.Wait() }()
连续启动 5 个协程，使用wg做协程等待，发送完毕再结束是为了交给defer关闭chanInt
接收端
go func() { var wg sync.WaitGroup for i := 0; i < 8; i++ { wg.Add(1) go received(chanInt, &wg) } wg.Wait() done <- struct{}{} }()
连续启动多个接收端，通道被关闭时纷纷退出，最后通知done
输出 5 个随机数，程序正常关闭。
5577006791947779410 8674665223082153551 4037200794235010051 6129484611666145821 3916589616287113937
单向通道限制了函数的使用方式，它可以用在循环比较耗时的场景，处理完一个数据立马发送出来，尽量减少内存的使用。
小结
这一节简单介绍了 go 语言中的 channel（信道），go 语言主张不要通过共享内存来通信，而应通过通信来共享内存，通过channel的方式可以完成不同goroutine之间的通信。
我们学会了：
channel 是引用类型默认值是nil，需要手动make。
通道必须在多个goroutine中使用
有缓冲与无缓冲通道的特点，什么时候会阻塞。
可以用range来做循环接收，通道关闭会自动停止。
只能且必须在发送端使用defer关闭通道。
正式使用一般多发送多接收，并使用done信号通知的方式进行通知。
在工作中，通道的使用更为复杂，下一节将介绍select，敬请期待
