16Go语言并发2——Channel

1、什么是channel

channel 是一种架设在goroutine之间进行 通信的管道，类似队列。channel是引用类型，类型为chan，可以通过make关键字进行创建指定类型的channel。channel存在的意义是让goroutine通过通信来共享内存，一个往通道发送数据，一个从通道获取数据，来实现数据同步。

2、channel的创建和传递

声明通道时，需要指定将要被共享的数据的类型。可以通过通道共享内置类型、命名类型、结构类型和引用类型的值或者指针。

2.1 make关键字创建

ch:=make(chan int) //创建一个int类型的channel,所以这个channel只能发送接收int型的数据
ch1:=make(chan int 10)//这个是有缓冲的buffer，这个下面会解释

2.2 <- 运算符 读和取

ch <- 2 //发送数值2给这个通道
x:=<-ch //从通道里读取值，并把读取的值赋值给x变量
<-ch //从通道里读取值，然后忽略

2.3 close 函数关闭channel

close(ch) //可以使用内置函数close关闭通道

如果一个通道被关闭了，我们就不能往这个通道里发送数据了，如果发送的话，会引起painc异常。但是，我们还可以接收通道里的数据，如果通道里没有数据的话，接收的数据是类型零值。

package main
import "fmt"
func main() {
ch:=make(chan int)//创建int 型的无缓冲的channel
go func() {
sum:=0
for i:=0;i<100;i++{
sum+=i
}
ch<-sum //将goroutine 算出的数放进通道
}()
fmt.Println(<-ch) //从通道获取数据，退出main函数，如果channel还没有存入数据，就会阻塞等待
}

上面这个简单的例子， 执行顺序是先创建一个channel，开启一个goroutine进行计算，然后打印从channel取出的数。会先执行fmt.Println(<-ch)，这时候goroutine还没有往里面写数据，此时main函数进入等待。一直到goroutine运算完将sum发送给channel，这时候main函数马上收到数据，打印完退出。

3、无缓冲的channel

无缓冲的通道指的是通道的大小为0，也就是说，这种类型的通道在接收前没有能力保存任何值，它要求发送goroutine和接收goroutine同时准备好，才可以完成发送和接收操作。

接下来看一个小案例，channel 好比是乒乓球的球桌，球好比数据，数据在channel通信就好比乒乓球在球桌上来回弹，而两个goroutine就是两位选手，这个就是无缓冲的channel的例子

package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
var wg sync.WaitGroup
func main() {
ch := make(chan int) //乒乓球台看做通道
wg.Add(2) //2个goroutine
//相当于两个选手对打
go player("张继科", ch)
go player("马龙", ch)
ch <- 1 //发球
wg.Wait() //等待比赛结束
}
func player(name string, ch chan int) {
defer wg.Done()//一方输了就告诉main函数，裁判不要等了
for {
ball, ok := <-ch
if !ok { //如果通道关闭
fmt.Printf("%s赢了！！\n", name)
return
}
n := rand.Intn(100)
if n%13 == 0 { //随机数来决定自己是否失误
fmt.Printf("%s输了\n", name)
close(ch) //输了就得关闭通道
return
}
fmt.Printf("%s击球第%d次\n", name, ball)
ball++
ch <- ball
}
}


从上面的例子看出，通道是球桌，球在球桌上来回传递，统计次数。两个选手用for循环持续的在接收和发送数据，也就是要么接球要么发球。之所以他们在相互等待对方是因为这个channel是一个无缓冲的channel，也就是球不能放在球桌上，球桌只管传递，不能存储。再看一个例子：

package main
import (
"fmt"
"sync"
"time"
)
var wg sync.WaitGroup
func main() {//4x100米接力比赛
ch:=make(chan int) //接力棒
wg.Add(1) //需要等待的是最后一棒
go runing(ch)
ch<-1
fmt.Println("比赛开始")
wg.Wait()
}
func runing(ch chan int){
var newRunner int
runner:=<-ch //接棒
fmt.Printf("第%d棒正在跑\n",runner)
time.Sleep(time.Second)//跑步中
if runner==4 {//第四棒
fmt.Printf("跑完了\n")
wg.Done()
return
}else{//没跑完，创建下一棒
newRunner=runner+1
fmt.Printf("第%d棒准备就绪\n",newRunner)
go runing(ch)//等待接棒
fmt.Printf("接力棒传递给第%d棒\n",newRunner)
ch<-newRunner //接力
}
}

上面的例子很有趣，模拟4&＃215;100米接力，我们创建一个无缓冲的channel，比作接力棒，只有双方都准备好接收和发送，接力才会发生，不然一方就会处于等待期。 传递给channel 一个数字1，表示比赛开始，第一棒取出runner，只要不是第4棒就需要往下一棒传递，所以，就创建了第二棒，让他准备继续接力。知道runner==4，比赛结束。

总结下：无缓冲channel，可存储的大小为0，它保证进行发送和接收的 goroutine 会在同一时间进行数据交换 。如果发送方没有准备好发送，接收方会进入阻塞，等待发送。

4、有缓冲的channel

有缓冲通道，其实是一个队列，这个队列的最大容量就是我们使用make函数创建通道时，通过第二个参数指定的。

ch := make(chan int, 5)

这里创建容量为5的，有缓冲的通道。对于有缓冲的通道，向其发送操作就是向队列的尾部插入元素，接收操作则是从队列的头部删除元素，并返回这个刚刚删除的元素。

当队列满的时候，发送操作会阻塞；当队列空的时候，接收操作会阻塞。有缓冲的通道，不要求发送和接收操作时同步的，相反可以解耦发送和接收操作。

// cap 和 len 函数同样对于有缓冲的channel可用，
cap(ch) //channel 容量
len(ch) //当前channel内的数量

看代码：

func mirroredQuery() string {
responses := make(chan string, 3)
go func() { responses <- request("asia.gopl.io") }()
go func() { responses <- request("europe.gopl.io") }()
go func() { responses <- request("americas.gopl.io") }()
return <-responses // return the quickest response
}
func request(hostname string) (response string) { /* ... */ }

我们定义了一个容量为3的通道responses，然后同时发起3个并发goroutine向这三个镜像获取数据，获取到的数据发送到通道responses中，最后我们使用return <-responses返回获取到的第一个数据，也就是最快返回的那个镜像的数据。

5、单项通道

为了避免channel混乱使用，还可以在定义的时候定义这个channel是单项的，即只能发送数据，或者只能接受数据。比如：

var send chan<- int //只能发送——只能往channel里发数据
var receive <-chan int //只能接收——只能从channel中取
//我们定义函数的时候，可以明确声明接受的参数
func test(ch chan<- int){
//接受的是一个只能发送数据的channel，
}

区别主要在于 <-符号的位置，在后面，往里发，，在前面，从里面取。好像一列车穿过隧道。

注意：不能把单项channel 转换为普通channel

d := (chan int)(send) // Error: cannot convert type chan<- int to type chan int
d := (chan int)(receive) // Error: cannot convert type <-chan int to type chan int

6、forange 迭代

package main
import (
"fmt"
)
func main() {
data := make(chan int) // 数据交换队列
exit := make(chan bool) // 退出通知
go func() {
for d := range data { // 从队列迭代接收数据，直到 close 。
fmt.Println(d)
}
fmt.Println("recv over.")
exit <- true // 发出退出通知。
}()
data <- 1 // 发送数据。
data <- 2
data <- 3
close(data) // 关闭队列。
fmt.Println("send over.")
<-exit // 等待退出通知。
}

forange 用于channel 有一个特点，就是一直进行迭代，不管channel有没有数据，直到channel （close）关闭。这样既安全又便利，当channel关闭时，for循环会自动退出，无需主动监测channel是否关闭，可以防止读取已经关闭的channel，造成读到数据为通道所存储的数据类型的零值。

7、select 关键字

之前的例子都是使用1个channel进行通信，当我们使用多个channel进行通信时，就需要用到 select关键字来进行管理。

• 可处理一个或多个channel的发送和接收
• 同时又多个可用的channel的按随机顺序处理
• 可用空的select来阻塞main函数
• 可设置超时
• 当通道为nil时，对应的case永远为阻塞，无论读写。特殊关注：而普通情况下，对nil的通道写操作是要panic的。

7.1 处理多个channel发送和接收

package main
import (
"fmt"
"os"
)
func main() {
a, b := make(chan int, 3), make(chan int)
go func() {
v, ok, s := 0, false, ""
for {
select { // 随机选择可用 channel，接收数据。
case v, ok = <-a:
s = "a"
case v, ok = <-b:
s = "b"
}
if ok {
fmt.Println(s, v)
} else {
os.Exit(0)
}
}
}()
for i := 0; i <5; i++ {
select { // 随机选择可用 channel，发送数据。
case a <- i:
case b <- i:
}
}
close(a)
select {} // 没有可用 channel，阻塞 main goroutine。
}


我们的例子中，使用select有点像switch， 它可以管理多个channel，随机的发送也可以随机的获取数据。最后我们用select{} 很巧妙的阻塞了main goroutine ,因为没有可用的channel，它进入阻塞直到channel 关闭，执行了os.Exit(0) main函数才推出。

7.2 设置超时

package main
import (
"fmt"
"time"
)
func main() {
exit := make(chan bool)
c1 := make(chan int, 2)
c2 := make(chan string, 2)
go func() {
select {
case vi := <-c1:
fmt.Println(vi)
case vs := <-c2:
fmt.Println(vs)
case <-time.After(time.Second * 3):
fmt.Println("timeout.")
}
exit <- true
}()
//我们先把发送数据代码注释掉。
//这里我们并没有向c1 和c2 发送任何数据，select 超时后就会打印 timeout
//c1<-10
//c2<-"加油"
<-exit
}

当然select 还有default ，但是在循环中使用default一定要小心，小心，小心。

8、channel 总结

channel存在3种状态

• nil，未初始化的状态，只进行了声明，或者手动赋值为nil
• active，正常的channel，可读或者可写
• closed,已关闭的channel。 关闭的channel存储的是类型零值。

对于nil通道的情况，也并非完全遵循上表，有1个特殊场景：当nil的通道在select的某个case中时，这个case会阻塞，但不会造成死锁。

• channel分为有缓冲和无缓冲
• channel 有单项channel
• 可以使用forange迭代，直到channel 关闭
• 可以用select 管理多个channel，随机处理读和写
• 可以用select{}阻塞main函数
• select 可以设置超时

9、channel 应用场景小结

9.1 forange 迭代，无需关注channel 是否关闭

场景：在需要不断从channel 取数据时，而不用关心channel是否关闭

for x := range ch{
fmt.Println(x)
}
//会一直迭代，直到channel 关闭

9.2 使用_,ok判断channel是否关闭

场景：在不确定channel是否关闭时，使用

if v, ok := <- ch; ok {
fmt.Println(v)
}

ok的含义：

• true：读到数据，并且通道没有关闭。
• false：通道关闭，无数据读到。

9.3使用select处理多个channel

场景：需要对多个通道进行同时处理，但只处理最先发生的channel时，见上面的例子

注意：当通道为nil时，对应的case永远为阻塞，无论读写。特殊关注：普通情况下，对nil的通道写操作是要panic的。

9.4 使用channel 传递结构体时，用指针

场景：channel 传递的数据是结构体时，最好用指针。

channel本质上传递的是数据的拷贝，拷贝的数据越小传输效率越高，传递结构体指针，比传递结构体更高效

9.5 简单⼯⼚模式打包并发任务和 channel

package main
import (
"math/rand"
"time"
)
func NewTest() chan int { //简单工厂方法返回一个channel
c := make(chan int)
rand.Seed(time.Now().UnixNano())
go func() {
time.Sleep(time.Second)
c <- rand.Int()
}()
//并且返回的channel 是已经准备好发送的，阻塞中，只要接收方一准备好，立马数据就传递出去了
return c
}
func main() {
t := NewTest()
println(<-t) // 等待 goroutine 结束返回。
}

9.6 ⽤channel 实现信号量 (semaphore)

简单解释下信号量，也叫信号灯，是可以用来保证两个或多个关键代码段不被并发调用。信号量有四种操作，1、初始化，2、等信号3、发信号4、清理

package main
import (
"fmt"
"sync"
)
func main() {
wg := sync.WaitGroup{}
wg.Add(3)
sem := make(chan int,1)
for i := 0; i <3; i++ {
go func(id int) {
defer wg.Done()
sem <- 1 // 向 sem 发送数据，阻塞或者成功。
fmt.Printf("第%d个\n",id)
for x := 0; x <3; x++ {
fmt.Println(id, x)
}
<-sem // 接收数据，使得其他阻塞 goroutine 可以发送数据。
}(i)
}
wg.Wait()
}
//输出
第2个
2 0
2 1
2 2
第0个
0 0
0 1
0 2
第1个
1 0
1 1
1 2


这里的channel 是一个容量为1的有缓冲的通道。也就是说，它只能存一个信号，比如开了3个goroutine，只有一个能发送进去，其他的都会阻塞，等到这个goroutine处理完自己的事情，将数据取出<-，那么第二个goroutine就会发送，执行，然后取出。接着是第三个goroutine。 这样就实现了信号量，保证goroutine一个个的执行。

9.7 利用从closed channel取值，发出退出的通知

应用场景：关闭所有下游的goroutine

nil 的channel在select 中是永久阻塞的，case是不会走的，但是关闭了的channel，就会走。

从关闭了的channel中取值 <- 是不会引发panic，会取出零值。

实现思路就是： 在channel取值，是阻塞的，只要一关闭channel，取值就是零值，然后执行退出就可以了。

通过将nil channel关闭，使select的 阻塞channel 变为取出零值， case退出代码执行，所有读取这个channel的goroutine就会执行关闭代码。

package main
import (
"sync"
"time"
)
func main() {
var wg sync.WaitGroup
quit := make(chan bool)
for i := 0; i <2; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
for {
select {
case <-quit: // closed channel 不会阻塞，会取出零值，因此可用作退出通知。
return
default: // 执行正常任务。
func() {
println(id, time.Now().Nanosecond())
time.Sleep(time.Second)
}()
}
}
}(i)
}
time.Sleep(time.Second * 5) // 让测试 goroutine 运⾏⼀会。
close(quit) // 发出退出通知。
wg.Wait()
}


9.8 channel作为结构成员

channel 可以做未结构体的成员，可以封装的更好。

package main
import (
"fmt"
)
type Request struct {
data []int
ret chan int
}
func NewRequest(data ...int) *Request {
return &Request{data, make(chan int, 1)}
}
//使用结构体指针，效率更高。
func Process(req *Request) {
x := 0
for _, i := range req.data {
x += i
}
req.ret <- x
}
func main() {
req := NewRequest(10, 20, 30)
Process(req)
fmt.Println(<-req.ret)
}