Go 信道Channel

信道(Channel)

信道（Channel）可以被认为是协程之间通信的管道。数据可以从信道的一端发送并在另一端接收。

默认为同步模式，需要发送和接收配对。否则会被阻塞，直到另外的信道准备好后被唤醒。

信道分为无缓冲信道和有缓冲信道
无缓冲信道：信道是同步的，接收前没有能力保存任何值。这种类型的信道只有发送和接收同时准备好，才能进行下次信道的操作，否则会导致阻塞。
有缓冲信道：信道是异步的，是一种在被创建时就被开辟了能存储一个或者多个值的信道。这种类型并不要求发送与接收同时进行。只要缓冲区有未使用空间用于发送数据，或还包含可以接收的数据，那么其通信就会无阻塞地进行。

发送与接收默认是阻塞的（同步的）。这是什么意思？当把数据发送到信道时，程序控制会在发送数据的语句处发生阻塞，直到有其它 Go 协程从信道读取到数据，才会解除阻塞。
与此类似，当读取信道的数据时，如果没有其它的协程把数据写入到这个信道，那么读取过程就会一直阻塞着。
信道的这种特性能够帮助 Go 协程之间进行高效的通信，不需要用到其他编程语言常见的显式锁或条件变量。

信道声明

var ch chan T

我们声明了一个T类型的名称叫做ch的信道
信道的 0 值为 nil。我们需要通过内置函数 make 来创建一个信道，就像创建 map 和 slice 一样。

无缓冲信道

ch := make(chan T)

有缓冲信道

ch := make(chan T,cap)

(1)信道的创建

     //内置类型channel
    var a chan int
    if a == nil {
        a = make(chan int)
        fmt.Printf("%T\n", a) //chan int
    }
    //自定义类型channel
    var p chan person
    if p == nil {
        p = make(chan person) //chan main.person
        fmt.Printf("%T\n", p)
    }

(2)通过信道发送和接收数据

注意：发送和接收默认是阻塞的

data := <- a // 从信道 a 中读取数据并将读取的值赋值给变量 data 。
a <- data // 向信道 a 中写入数据。

package main
import (
    "fmt"
    "time"
)
func hello(done chan bool) {
    fmt.Println("hello go routine is going to sleep")
    time.Sleep(4 * time.Second)
    //只有写数据后才能继续执行
    done <- true
    fmt.Println("hello go routine awake and going to write to done")
}
func main() {
    done := make(chan bool)
    go hello(done)
    <-done
    fmt.Println("Main received data")
}

(4)死锁

当 Go 协程给一个信道发送数据时，照理说会有其他 Go 协程来接收数据。如果没有的话，程序就会在运行时触发 panic，形成死锁。

同理，当有 Go 协程等着从一个信道接收数据时，我们期望其他的 Go 协程会向该信道写入数据，要不然程序就会触发 panic。

package main

func main() {  
    ch := make(chan int)
    ch <- 5
}

(5)单向信道与双向信道

双向信道：即通过信道既能发送数据，又能接收数据。
单向信道：信道只能发送或者接收数据。

单向信道：

package main

import "fmt"

func sendData(sendch chan<- int) {  
    sendch <- 10
}

func main() {  
    sendch := make(chan<- int)    
    go sendData(sendch)
    fmt.Println(<-sendch)
}

chan<- int 定义了唯送信道，因为箭头指向了 chan。我们在主函数中试图通过唯送信道接收数据，于是编译器报错：
invalid operation: <-sendch (receive from send-only type chan<- int)
一切都很顺利，只不过一个不能读取数据的唯送信道究竟有什么意义呢？
这就需要用到信道转换（Channel Conversion）了。把一个双向信道转换成唯送信道或者唯收（Receive Only）信道都是行得通的，但是反过来就不行。

package main

import "fmt"

func sendData(sendch chan<- int) {  
    sendch <- 10
}
func main() {  
    cha1 := make(chan int)    
    go sendData(cha1)
    fmt.Println(<-cha1)
}

我们创建了一个双向信道 cha1。 cha1 作为参数传递给了 sendData 协程。函数 sendData 里的参数 sendch chan<- int 把 cha1 转换为一个唯送信道。
于是该信道在 sendData 协程里是一个唯送信道，而在 Go 主协程里是一个双向信道。该程序最终打印输出 10。

(6)关闭信道

数据发送方可以关闭信道，通知接收方这个信道不再有数据发送过来。

当从信道接收数据时，接收方可以多用一个变量来检查信道是否已经关闭。

v, ok := <- ch
上面的语句里，如果成功接收信道所发送的数据，那么 ok 等于 true。而如果 ok 等于 false，说明我们试图读取一个关闭的通道。
从关闭的信道读取到的值会是该信道类型的零值。例如，当信道是一个 int 类型的信道时，那么从关闭的信道读取的值将会是 0。

package main

import (  
    "fmt"
)

func producer(chnl chan int) {  
    for i := 0; i < 10; i++ {
        chnl <- i
    }    close(chnl)
}

func main() {  
    ch := make(chan int)    
    go producer(ch)    
    for {
        v, ok := <-ch        
        if ok == false {            
            break
        }
        fmt.Println("Received ", v, ok)
    }
}

在上述的程序中，producer 协程会从 0 到 9 写入信道 chn1，然后关闭该信道。
主函数有一个无限的 for 循环，使用变量 ok检查信道是否已经关闭。如果 ok 等于 false，说明信道已经关闭，于是退出 for 循环。
如果 ok 等于 true，会打印出接收到的值和 ok 的值。

(7)遍历信道

信道支持range for遍历

package main

import (
    "fmt"
    "time"
)

func producer(chnl chan int) {
    defer close(chnl) //程序执行结束关闭信道
    for i := 0; i < 10; i++ {
        time.Sleep(300 * time.Millisecond) //一秒写一次
        chnl <- i                          //写操作
    }
}
func main() {
    ch := make(chan int)
    go producer(ch)
    //接收ch信道中的数据，直到该信道关闭。
    for v := range ch {
        fmt.Println(v)
    }
}　

也可以自定for循环遍历信道

for {
        v, ok := <-ch //读操作
        fmt.Println(v, ok)
        if ok == false { //当读取不到数据跳出循环
            break
        }
    }