golang 无缓存channel和有缓存channel
无缓存通道
var ch = make(chan int) // 创建一个int类型的channel
cap(ch) // ch的容量是0
-
发送/存入
ch <- 1 // 存入一个int类型的值 -
接收/取出
x := <-ch // 取出ch中的值，并赋值给x -
关闭
close(ch) // 关闭发送方channel，对接收发channel关闭操作会panic val, ok := <-ch // ok 可用于判断通道是否关闭。
| 操作 | nil | closed channel |
| :---: | :---: | :------------------------: |
| close | panic | panic |
| 存入 | 阻塞 | panic |
| 取出 | 阻塞 | 返回对应类型零值和关闭信号 |
了解了channel的基本语法，我们看一个例子
```go
func main() {
ch := make(chan int) // 创建一个无缓存channel
ch <- 233
fmt.Println(<-ch)
}
上面的代码可以成功执行吗？答案是否定的。会出现死锁。这是因为 ch是一个无缓存的channel，当我们向它存入值的时候，会阻塞所在goroutine，这里当然是main.main的goroutine，后面的语句根本不会执行到。那么我们应该怎么修改呢，继续看代码：
func main() {
ch := make(chan int)
go func(chan int) { ch <- 233 }(ch)
fmt.Println(<-ch)
}
这里我们在main.main 主goroutine 中新建了一个goroutine，这样阻塞的就是这个goroutine了，不影响main.main。当主协程执行到<-ch的时候，取出值，完成一次同步通信。
一句话总结：无缓存的channel只有在receiver准备好后send才被执行，也就是说receiver的goroutine 和sender的goroutine 必须成对出现
之前看到一个打网球的模拟，很有趣，可以加深一下理解，我们看一下
package main
import(
"math/rand"
"sync"
"time"
"fmt"
)
// wg用来等待程序结束
var wg sync.WaitGroup
func init() {
rand.Seed(time.Now().UnixNano())
}
// main是所有Go程序的入口
func main() {
// 创建一个无缓冲的通道
court := make(chan int)
// 计数加2，表示要等待两个goroutine
wg.Add(2)
// 启动两个选手
go player("Nick", court)
go player("Jack", court)
// 发球
court <- 1
// 等待游戏结束
wg.Wait()
}
// player 模拟一个选手在打网球
func player(name string, court chan int) {
// 在函数退出时调用Done来通知main函数工作已经完成
defer wg.Done()
for{
// 等待球被击打过来
ball, ok := <-court
if !ok {
// 如果通道被关闭，我们就赢了
fmt.Printf("Player %s Won\n", name)
return
}
// 选随机数，然后用这个数来判断我们是否丢球
n := rand.Intn(100)
if n%5 == 0 {
fmt.Printf("Player %s Missed\n", name)
// 关闭通道，表示我们输了
close(court)
return
}
// 显示击球数，并将击球数加1
fmt.Printf("Player %s Hit %d\n", name, ball)
ball++
// 将球打向对手
court <- ball
}
}
E:\go\src\learngolang\00test>go run main.go
Player Jack Hit 1
Player Nick Hit 2
Player Jack Hit 3
Player Nick Hit 4
Player Jack Hit 5
Player Nick Hit 6
Player Jack Hit 7
Player Nick Hit 8
Player Jack Hit 9
Player Nick Missed
Player Jack Won
上面的go函数为什么能交替执行呢？首先，我们有main主协程g0，里面创建了两个goroutine，g1，g2，然后，主协程g0向无缓存channel中发送数据，g0阻塞，这时，g1、g2中某一个，如g2，先进入通道的接收队列，则通道获得一次同步，g0取消阻塞。在player函数中court <- ball 这句代码继续向通道发送数据，g2阻塞，这时通道中g1等待接收，g1开始执行，通道接收操作之后，g2取消阻塞，for循环继续等待接收，阻塞，g1最后向通道发送数据，g1阻塞；g2接收数据....直到goroutine结束运行。
WaitGroup是用来让g0等待g1、g2执行的。因为当程序执行到一条go语句时，Go语言的运行时系统，会试图从某个存放空闲的G队列中获取一个G（也就是goroutine），没有则创建一个新的G。Go语言运行时系统会用这个G去包装当前的那个go函数（或者说该函数中的那些代码），然后再把这个G追加到某个存放可运行的G的队列中。这类队列中的G总是会按照先入先出的顺序，很快地由运行时系统内部的调度器安排运行。虽然这会很快，但是由于上面所说的那些准备工作还是不可避免的，所以耗时还是存在的。因此，go函数的执行时间总是会明显滞后于它所属的go语句的执行时间。不然，主goroutine代码执行完关闭，其创建的其他goroutine还没来得及执行也就跟着关闭了。
有缓存channel
var ch = make(chan int, 10) //创建一个有缓存的channel，容量是10，即可以传入10个int类型的值
发送
接收
-
关闭
func main() { ch := make(chan int, 10) for i := 0; i < 5; i++ { ch <- i + 1 // 向channel中传入5 个值 } fmt.Println(len(ch)) // 5 // channel长度为5 close(ch) // 关闭channel fmt.Println("--------------") for x := range ch { // range的截止条件是channel关闭，即关闭前存入多少个值，range的范围是多少，如果range的对象没有关闭，则最终阻塞，引起panic fmt.Println(x) // 接收一个，channel的有效值少一个 } fmt.Println("--------------") fmt.Println(len(ch)) // 0 // channel 长度为0 fmt.Println(cap(ch)) // 10 // channel容量为10 }
| 操作 | nil | 满 | 空 | closed channel |
|---|---|---|---|---|
| close | panic | 关闭 | 关闭 | panic |
| 存入 | 阻塞 | 阻塞 | 成功发送 | panic |
| 取出 | 阻塞 | 成功接收 | 阻塞 | 空：返回类型零值、false<br />非空：返回相应值、true |
buffer没满则，写入\发送 不会阻塞；buffer不空，则读取\接收 不会阻塞。发送和接收不是同步的。但多说一句，其实这种情况不太常用，原因也很简单。因为上下游的消费情况是统一的，如果生产者生产的速度过快，而消费端跟不上的话，即使把它先暂存在缓冲区当中也没什么用，早晚还是会要阻塞的。
