1.  channel是goroutine之间的通信机制，它可以让一个goroutine通过它给另一个goroutine发送数据，每个channel在创建的时候必须指定一个类型，指定的类型是任意的。<br />     使用内置的make函数，可以创建一个channel类型：
  1. ch := make(chan int)

发送和接收

  1.  channel主要的操作有发送和接收：
  1. // 发送数据到channel
  2. ch <- 1
  3. // 从channel接受数据
  4. x := <- ch

如向channel发送数据的时候，该goroutine会一直阻塞直到另一个goroutine接受该channel的数据，反之亦然，goroutine接受channel的数据的时候也会一直阻塞直到另一个goroutine向该channel发送数据，如下面操作：

  1. func main() {
  2.     ch := make(chan string)
  3.     // 在此处阻塞，然后程序会弹出死锁的报错
  4.     c <- "hello"
  5.     fmt.Println("channel has send data")
  6. }

正确的操作：

  1. func main() {
  2.     ch := make(chan string)
  3.     go func(){
  4.         // 在执行到这一步的时候main goroutine才会停止阻塞
  5.         str := <- ch
  6.         fmt.Println("receive data：" + str)
  7.     }()
  8.     ch <- "hello"
  9.     fmt.Println("channel has send data")
  10. }

说到channel的阻塞，就不得不说到有缓冲的channel。

带缓冲的channel

  1.  带缓冲的channel的创建和不带缓冲的channel（也就是上面用的channel）的创建差不多，只是在make函数的第二个参数指定缓冲的大小。
  1. // 创建一个容量为10的channel
  2. ch := make(chan int, 10)


带缓冲的channel就像一个队列，遵从先进先从的原则，发送数据向队列尾部添加数据，从头部接受数据。
Go之channel - 图1
goroutine向channel发送数据的时候如果缓冲还没满，那么该goroutine就不会阻塞。

  1. ch := make(chan int, 2)
  2. // 前面两次发送数据不会阻塞，因为缓冲还没满
  3. ch <- 1
  4. ch <- 2
  5. // goroutine会在这里阻塞
  6. ch <- 3
  1.   反之如果接受该channel数据的时候，如果缓冲有数据，那么该goroutine就不会阻塞。<br />       channel与goroutine之间的应用可以想象成某个工厂的流水线工作，流水线上面有打磨，上色两个步骤（两个goroutine），负责打磨的工人生产完成后会传给负责上色的工人，上色的生产依赖于打磨，两个步骤之间的可能存在存放槽（channel），如果存放槽存满了，打磨工人就不能继续向存放槽当中存放产品，直到上色工人拿走产品，反之上色工人如果把存放槽中的产品都上色完毕，那么他就只能等待新的产品投放到存放槽中。

备注

  1.     其实在实际应用中，带缓冲的channel用的并不多，继续拿刚才的流水线来做案例，如果打磨工人生产速度比上色工人工作速度要快，那么即便再多容量的channel，也会迟早被填满然后打磨工人会被阻塞，反之如果上色工人生产速度大于打磨工人速度，那么有缓冲的channel也是一直处于没有数据，上色工人很容易长时间处于阻塞的状态。
  3.    因此比较好的解决方法还是针对生产速度较慢的一方多加人手，也就是多开几个goroutine来进行处理，有缓冲的channel最好用处只是拿来防止goroutine的完成时间有一定的波动，需要把结果缓冲起来，以平衡整体channel通信。

单方向的channel

  1.    使用channel来使不同的goroutine去进行通信，很多时候都和消费者生产者模式很相似，一个goroutine生产的结果都用channel传送给另一个goroutine，一个goroutine的执行依赖与另一个goroutine的结果。<br />        因此很多情况下，channel都是单方向的，在go里面可以把一个无方向的channel转换为只接受或者只发送的channel，但是却不能反过来把接受或发送的channel转换为无方向的channel，适当地把channel改成单方向，可以达到程序强约束的做法，类似于下面例子：
  1. fuc main(){
  2.     ch := make(ch chan string)
  4.     go func(out chan<- string){
  5.         out <- "hello"
  6.     }(ch)
  8.     go func(in <-chan string){
  9.         fmt.Println(in)
  10.     }(ch)
  12.     time.Sleep(2 * time.Second)
  13. }

select多路复用

  1.   在一个goroutine里面，对channel的操作很可能导致我们当前的goroutine阻塞，而我们之后的操作都进行不了。而如果我们又需要在当前channel阻塞进行其他操作，如操作其他channel或直接跳过阻塞，可以通过select来达到多个channel（可同时接受和发送）复用。如下面我们的程序需要同时监听多个频道的信息：
  1. broadcaster1 := make(chan string) // 频道1
  2. broadcaster2 := make(chan string) // 频道2
  3. select {
  4.     case mess1 := <-broadcaster1:
  5.         fmt.Println("来自频道1的消息：" + mess1)
  6.     case mess2 := <-broadcaster2:
  7.         fmt.Println("来自频道2的消息：" + mess2)
  8.     default:
  9.         fmt.Println("暂时没有任何频道的消息，请稍后再来~")
  10.         time.Sleep(2 * time.Second)
  11. }

select和switch语句有点相似，找到匹配的case执行对应的语句块，但是如果有两个或以上匹配的case语句，那么则会随机选择一个执行，如果都不匹配就会执行default语句块（如果含有default的部分的话）。 值得注意的是，select一般配合for循环来达到不断轮询管道的效果，可能很多小伙伴想着写个在某个case里用break来跳出for循环，这是不行的，因为break只会退出当前case，需要使用return来跳出函数或者弄个标志位标记退出

  1. var flag = 0
  2. for {
  3.     if flag == 1 {break}
  4.     select {
  5.         case message := <- user.RecMess :
  6.             event := gjson.Get(string(message), "event").String()
  7.             if event == "login" {
  8.                 Login(message, user)
  9.             }
  10.             break
  11.         case <- user.End :
  12.             flag = 1
  13.             break
  14.     }
  15. }

关闭

  1.   channel可以接受和发送数据，也可以被关闭。
  1. close(ch)

关闭channel后，所有向channel发送数据的操作都会引起panic，而被close之后的channel仍然可以接受之前已经发送成功的channel数据，如果数据全部接受完毕，那么再从channel里面接受数据只会接收到零值得数据。

  1.    channel的关闭可以用来操作其他goroutine退出，在运行机制方面，goroutine只有在自身所在函数运行完毕，或者主函数运行完毕才会打断，所以我们可以利用channel的关闭作为程序运行入口的一个标志位，如果channel关闭则停止运行。
  3.    无法直接让一个goroutine直接停止另一个goroutine，但可以使用通信的方法让一个goroutine停止另一个goroutine，如下例子就是程序一边运行，一边监听用户的输入，如果用户回车，则退出程序。
  1. func main() {
  2.     shutdown := make(chan struct{})
  3.     var n sync.WaitGroup
  4.     n.Add(1)
  5.     go Running(shutdown, &n) 
  6.     n.Add(1)
  7.     go ListenStop(shutdown, &n) 
  8.     n.Wait()
  9. }
  11. func Running(shutdown <-chan struct{}, n *sync.WaitGroup) {
  12.     defer n.Done()
  13.     for {
  14.         select {
  15.         case <-shutdown:
  16.             // 一旦关闭channel，则可以接收到nil。
  17.             fmt.Println("shutdown goroutine")
  18.             return
  19.         default:
  20.             fmt.Println("I am running")
  21.             time.Sleep(1 * time.Second)
  22.         }   
  23.     }   
  24. }
  26. func ListenStop(shutdown chan<- struct{}, n *sync.WaitGroup) {
  27.     defer n.Done()
  28.     os.Stdin.Read(make([]byte, 1)) 
  29.     // 如果用户输入了回车则退出关闭channel
  30.     close(shutdown)
  31. }
  1.  利用channel关闭时候的传送的零值信号可以有效地退出其他goroutine，特别是关闭多个goroutine的时候，就不需要向channel传输多个信息了。

Go之channel - 图2