1.channel的作用
Channel 是 Go 语言中一个十分重要的类型，是 Go 里的第一对象。通过 channel，Go 实现了通过通信来实现内存共享， 实际上：（数据拷贝了一份，并通过 channel 传递，实质就是个队列）。Channel 是在多个goroutine 之间传递数据和同步的重要伎俩。应用原子函数、读写锁能够保障资源的共享拜访平安，但应用channel 更优雅。
channel 字面意义是 “通道”，相似于 Linux 中的管道。申明 channel 的语法如下：
chan ch // 申明一个双向通道chan<- ch // 申明一个只能用于发送的通道<-chan ch // 申明一个只能用于接管的通道COPYch <- v // 发送值v到Channel ch中v := <-ch // 从Channel ch中接收数据，并将数据赋值给v// 就像 map 和 slice 数据类型一样, channel必须先创立再应用:ch := make(chan int)单向通道的申明，用 <- 来示意，它指明通道的方向。你只有明确，代码的书写程序是从左到右就马上能把握通道的方向是怎么的。
因为 channel 是一个援用类型，所以在它被初始化之前，它的值是 nil，channel 应用 make函数进行初始化。能够向它传递一个 int 值，代表 channel 缓冲区的大小（容量），结构进去的是一个缓冲型的 channel；不传或传 0 的，结构的就是一个非缓冲型的 channel。
两者有一些差异：非缓冲型 channel 无奈缓冲元素，对它的操作肯定程序是 “发送 -> 接管 -> 发送 -> 接管 -> ……”，如果想间断向一个非缓冲 chan 发送 2 个元素，并且没有接管的话，第一次肯定会被阻塞；对于缓冲型 channel 的操作，则要 “宽松” 一些，毕竟是带了 “缓冲” 光环。
对 chan 的发送和接管操作都会在编译期间转换成为底层的发送接管函数。
v, ok := <-ch它能够用来查看Channel是否曾经被敞开了
2.同步与异步
Channel 分为两种：带缓冲、不带缓冲。对不带缓冲的 channel 进行的操作实际上能够看作 “同步模式”，带缓冲的则称为 “异步模式”。
同步模式下，发送方和接管方要同步就绪，只有在两者都 ready 的状况下，数据能力在两者间传输（前面会看到，实际上就是内存拷贝）。否则，任意一方后行进行发送或接管操作，都会被挂起，期待另一方的呈现能力被唤醒。
异步模式下，在缓冲槽可用的状况下（有残余容量），发送和接管操作都能够顺利进行。否则，操作的一方（如写入）同样会被挂起，直到呈现相同操作（如接管）才会被唤醒。
个性：【Go - Channel 原理】
- 给一个 nil channel 发送数据，造成永远阻塞
- 从一个 nil channel 接收数据，造成永远阻塞
- 给一个曾经敞开的 channel 发送数据，引起 panic
- 从一个曾经敞开的 channel 接收数据，如果缓冲区中为空，则返回一个零值
- 无缓冲的channel是同步的，而有缓冲的channel是非同步的
以上5个个性是死货色，也能够通过口诀来记忆：空读写阻塞，写敞开异样，读敞开空零。
blocking
默认状况下，发送和接管会始终阻塞着，直到另一方筹备好。这种形式能够用来在gororutine中进行同步，而不用应用显示的锁或者条件变量。
如官网的例子中x, y := <-c, <-c这句会始终期待计算结果发送到channel中。
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)}Range
for …… range语句能够解决Channel。
for ... range c { do } 这种写法相当于 if _, ok := <-c; ok { do }
func main() { go func() { time.Sleep(1 * time.Hour) }() c := make(chan int) go func() { for i := 0; i < 10; i = i + 1 { c <- i } close(c) }() for i := range c { fmt.Println(i) } fmt.Println("Finished")}range c产生的迭代值为Channel中发送的值，它会始终迭代直到channel被敞开。下面的例子中如果把close(c)正文掉，程序会始终阻塞在for …… range那一行（不会报错）。
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.Cfmt.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。
func TestClose(t *testing.T) { 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 <- 1c <- 2close(c)fmt.Println(<-c) //1fmt.Println(<-c) //2fmt.Println(<-c) //0fmt.Println(<-c) //0然而如果通过range读取，channel敞开后for循环会跳出：
c := make(chan int, 10)c <- 1c <- 2close(c)for i := range c { fmt.Println(i)}通过i, ok := <-c能够查看Channel的状态，判断值是零值还是失常读取的值。
c := make(chan int, 10)close(c)i, ok := <-cfmt.Printf("%d, %t", i, ok) //0, false同步
channel能够用在goroutine之间的同步。
上面的例子中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}限度最大并发数
// 最大并发数为 2limits := make(chan struct{}, 2)for i := 0; i < 10; i++ { go func() { // 缓冲区满了就会阻塞在这 limits <- struct{}{} do() <-limits }()}总结一下channel敞开后sender的receiver操作。
如果channel c曾经被敞开,持续往它发送数据会导致panic: send on closed channel:
小结：
同步模式下，必须要使发送方和接管方配对，操作才会胜利，否则会被阻塞；异步模式下，缓冲槽要有残余容量，操作才会胜利，否则也会被阻塞。
简略来说，CSP 模型由并发执行的实体（线程或者过程或者协程）所组成，实体之间通过发送音讯进行通信，这里发送音讯时应用的就是通道，或者叫 channel。
CSP 模型的要害是关注channel，而不关注发送音讯的实体。Go 语言实现了CSP 局部实践，goroutine 对应 CSP 中并发执行的实体，channel 也就对应着 CSP 中的 channel。
参考资料
Go语言的CSP模型
Go Channel 详解