在golang中，channel是一个比较核心的功能，作为goroutine之间通信的一种方式，channel和linux系统中管道/消息队列比较类似。但不同之处在于，channel在golang中，提倡基于通信实现内存共享（linux是基于内存实现通信），重点是如何利用channel节省内存，共享消息。
channel的定义
channelType = （"chan" | "chan" "<-" | "<-" "chan"） ElementType
chan T // 可以接受和发送类型为 T 的数据
chan<- float64 // 只可以用来发送float64类型的数据
<- chan int // 只可以用来接受int类型的数据
与slice、map类型，可以使用make关键字来初始化channel
ch1 := make(chan int) // 定义无缓冲的整形通道
ch2 := make(chan string,10) // 定义有缓冲的字符串通道
有缓冲的channel可以部分避免阻塞读取操作
容量(capacity)代表Channel容纳的最多的元素的数量，代表Channel的缓存的大小。
如果没有设置容量，或者容量设置为0, 说明Channel没有缓存，只有sender和receiver都准备好了后它们的通讯(communication)才会发生(Blocking)。如果设置了缓存，就有可能不发生阻塞， 只有buffer满了后 send才会阻塞， 而只有缓存空了后receive才会阻塞。一个nil channel不会通信。
可以通过内建的close方法可以关闭Channel。
你可以在多个goroutine从/往 一个channel 中 receive/send 数据, 不必考虑额外的同步措施。
Channel可以作为一个先入先出(FIFO)的队列，接收的数据和发送的数据的顺序是一致的。
channel的功能
channel的通信作用
package main
import (
"fmt"
"time"
)
func main() {
resCh := make(chan string)
go func() {
for i := 0; i < 5; i++ {
time.Sleep(1 * time.Second)
resCh <- fmt.Sprintf("执行任务完成: %d", i)
}
// close(resCh) // 1.避免channel读写进入deadlock，子goroutine写入结束之后，主动close
}()
for {
i, ok := <-resCh
if !ok {
break
}
fmt.Println(i)
}
// for i := 0; i < 5; i++ { // 2.避免channel读写进入deadlock,在已经数据写入5次之后，通过for也只读取5次
// fmt.Println(<-resCh)
// }
}
输出结果：
执行任务结果: 0
执行任务结果: 1
执行任务结果: 2
执行任务结果: 3
执行任务结果: 4
fatal error: all goroutines are asleep - deadlock!
这里可以看到main线程（主goroutine协程），里面开启了一个子协程，将执行结果写入到channel中，并在main线程中读出,以实现子协程的数据在main线程中展示。
注意，这里读取完5个任务之后，报错 fatal error: all goroutines are asleep - deadlock! 只是因为main线程期待不断从管道中读取数据，但数据必须是其他goroutine线程放进管道的，但是其他goroutine线程都已经执行完了，再也没有数据写入而main线程将等待不到新的数据读出，因此报错给系统目前进入了一个死锁等待（deadlock）。解决办法有两种：
1.在其他goroutine中，没有数据写入之后，进行close操作
2.在已经数据写入5次之后，通过for也只读取5次
channel的同步作用(blocking)
默认情况下，发送和接收会一直阻塞着，直到另一方准备好。这种方式可以用来在gororutine中进行同步，而不必使用显示的锁或者条件变量。
import "fmt"
func sum(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
c <- sum // send sum to c
}
func main() {
s := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go sum(s[:len(s)/2], c)
go sum(s[len(s)/2:], c)
x, y := <-c, <-c // receive from c
fmt.Println(x, y, x+y)
}
如官方的例子中x, y := <-c, <-c这句会一直等待计算结果发送到channel中。
样例2：main goroutine通过done channel等待worker完成任务。 worker做完任务后只需往channel发送一个数据就可以通知main goroutine任务完成。
import (
"fmt"
"time"
)
func worker(done chan bool) {
time.Sleep(time.Second)
// 通知任务已完成
done <- true
}
func main() {
done := make(chan bool, 1)
go worker(done)
// 等待任务完成
<-done
}
range
如上面样例中:
for {
i, ok := <-resCh
if !ok {
break
}
fmt.Println(i)
}
可以用range遍历
for res := range resCh {
fmt.Println(res)
}
range channel 产生的迭代值为channel中发送的值，会一直迭代到channel被关闭，也就是说如果close(resCh)代码注释，同样程序会一直阻塞再for .... range 这里面，进入deadlock错误
select
select语句选择一组可能的send操作和receive操作去处理。它类似switch,但是只是用来处理通讯(communication)操作。
它的case可以是send语句，也可以是receive语句，亦或者default。
receive语句可以将值赋值给一个或者两个变量。它必须是一个receive操作。
最多允许有一个default case,它可以放在case列表的任何位置，尽管我们大部分会将它放在最后。
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}
如果有同时多个case去处理,比如同时有多个channel可以接收数据，那么Go会伪随机的选择一个case处理(pseudo-random)。如果没有case需要处理，则会选择default去处理，如果default case存在的情况下。如果没有default case，则select语句会阻塞，直到某个case需要处理。
需要注意的是，nil channel上的操作会一直被阻塞，如果没有default case,只有nil channel的select会一直被阻塞。
select语句和switch语句一样，它不是循环，它只会选择一个case来处理，如果想一直处理channel，你可以在外面加一个无限的for循环：
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
timeout
select有很重要的一个应用就是超时处理。 因为上面我们提到，如果没有case需要处理，select语句就会一直阻塞着。这时候我们可能就需要一个超时操作，用来处理超时的情况。
下面这个例子我们会在2秒后往channel c1中发送一个数据，但是select设置为1秒超时,因此我们会打印出timeout 1,而不是result 1。
import "time"
import "fmt"
func main() {
c1 := make(chan string, 1)
go func() {
time.Sleep(time.Second * 2)
c1 <- "result 1"
}()
select {
case res := <-c1:
fmt.Println(res)
case <-time.After(time.Second * 1):
fmt.Println("timeout 1")
}
}
其实它利用的是time.After方法，它返回一个类型为<-chan Time的单向的channel，在指定的时间发送一个当前时间给返回的channel中。
Timer和Ticker
我们看一下关于时间的两个Channel。
timer是一个定时器，代表未来的一个单一事件，你可以告诉timer你要等待多长时间，它提供一个Channel，在将来的那个时间那个Channel提供了一个时间值。下面的例子中第二行会阻塞2秒钟左右的时间，直到时间到了才会继续执行。
timer1 := time.NewTimer(time.Second * 2)
<-timer1.C
fmt.Println("Timer 1 expired")
当然如果你只是想单纯的等待的话，可以使用time.Sleep来实现。
你还可以使用timer.Stop来停止计时器。
timer2 := time.NewTimer(time.Second)
go func() {
<-timer2.C
fmt.Println("Timer 2 expired")
}()
stop2 := timer2.Stop()
if stop2 {
fmt.Println("Timer 2 stopped")
}
ticker是一个定时触发的计时器，它会以一个间隔(interval)往Channel发送一个事件(当前时间)，而Channel的接收者可以以固定的时间间隔从Channel中读取事件。下面的例子中ticker每500毫秒触发一次，你可以观察输出的时间。
ticker := time.NewTicker(time.Millisecond * 500)
go func() {
for t := range ticker.C {
fmt.Println("Tick at", t)
}
}()
类似timer, ticker也可以通过Stop方法来停止。一旦它停止，接收者不再会从channel中接收数据了。
close
内建的close方法可以用来关闭channel。
总结一下channel关闭后sender的receiver操作。
如果channel c已经被关闭,继续往它发送数据会导致panic: send on closed channel:
import "time"
func main() {
go func() {
time.Sleep(time.Hour)
}()
c := make(chan int, 10)
c <- 1
c <- 2
close(c)
c <- 3
}
但是从这个关闭的channel中不但可以读取出已发送的数据，还可以不断的读取零值:
c := make(chan int, 10)
c <- 1
c <- 2
close(c)
fmt.Println(<-c) //1
fmt.Println(<-c) //2
fmt.Println(<-c) //0
fmt.Println(<-c) //0
但是如果通过range读取，channel关闭后for循环会跳出：
c := make(chan int, 10)
c <- 1
c <- 2
close(c)
for i := range c {
fmt.Println(i)
}
通过i, ok := <-c可以查看Channel的状态，判断值是零值还是正常读取的值。
c := make(chan int, 10)
close(c)
i, ok := <-c
fmt.Printf("%d, %t", i, ok) //0, false