Go语言中 Channel 详解
Channel是Go中的一个核心类型，你可以把它看成一个管道，通过它并发核心单元就可以发送或者接收数据进行通讯(communication)。
它的操作符是箭头<-。
ch<-v //发送值v到Channelch中
v:=<-ch //从Channelch中接收数据，并将数据赋值给v
(箭头的指向就是数据的流向)
就像map和slice数据类型一样,channel必须先创建再使用:
ch:=make(chanint)
Channel类型
Channel类型的定义格式如下：
ChannelType=("chan"|"chan""<-"|"<-""chan")ElementType.
它包括三种类型的定义。可选的<-代表channel的方向。如果没有指定方向，那么Channel就是双向的，既可以接收数据，也可以发送数据。
chanT //可以接收和发送类型为T的数据
chan<-float64 //只可以用来发送float64类型的数据
<-chanint //只可以用来接收int类型的数据
<-总是优先和最左边的类型结合。(The<-operatorassociateswiththeleftmostchanpossible)
chan<-chanint //等价chan<-(chanint)
chan<-<-chanint //等价chan<-(<-chanint)
<-chan<-chanint //等价<-chan(<-chanint)
chan(<-chanint)
使用make初始化Channel,并且可以设置容量:
make(chanint,100)
容量(capacity)代表Channel容纳的最多的元素的数量，代表Channel的缓存的大小。
如果没有设置容量，或者容量设置为0,说明Channel没有缓存，只有sender和receiver都准备好了后它们的通讯(communication)才会发生(Blocking)。如果设置了缓存，就有可能不发生阻塞，只有buffer满了后send才会阻塞，而只有缓存空了后receive才会阻塞。一个nilchannel不会通信。
可以通过内建的close方法可以关闭Channel。
你可以在多个goroutine从/往一个channel中receive/send数据,不必考虑额外的同步措施。
Channel可以作为一个先入先出(FIFO)的队列，接收的数据和发送的数据的顺序是一致的。
channel的receive支持multi-valuedassignment，如
v,ok:=<-ch
它可以用来检查Channel是否已经被关闭了。
send语句
send语句用来往Channel中发送数据，如ch<-3。
它的定义如下:
SendStmt=Channel"<-"Expression.
Channel =Expression.
在通讯(communication)开始前channel和expression必选先求值出来(evaluated)，比如下面的(3+4)先计算出7然后再发送给channel。
c:=make(chanint)
deferclose(c)
gofunc(){c<-3+4}()
i:=<-c
fmt.Println(i)
send被执行前(proceed)通讯(communication)一直被阻塞着。如前所言，无缓存的channel只有在receiver准备好后send才被执行。如果有缓存，并且缓存未满，则send会被执行。
往一个已经被close的channel中继续发送数据会导致run-timepanic。
往nilchannel中发送数据会一致被阻塞着。
receive操作符
<-ch用来从channelch中接收数据，这个表达式会一直被block,直到有数据可以接收。
从一个nilchannel中接收数据会一直被block。
从一个被close的channel中接收数据不会被阻塞，而是立即返回，接收完已发送的数据后会返回元素类型的零值(zerovalue)。
如前所述，你可以使用一个额外的返回参数来检查channel是否关闭。
x,ok:=<-ch
x,ok=<-ch
varx,ok=<-ch
如果OK是false，表明接收的x是产生的零值，这个channel被关闭了或者为空。
blocking
缺省情况下，发送和接收会一直阻塞着，直到另一方准备好。这种方式可以用来在gororutine中进行同步，而不必使用显示的锁或者条件变量。
如官方的例子中x,y:=<-c,<-c这句会一直等待计算结果发送到channel中。
import"fmt"
funcsum(s[]int,cchanint){
sum:=0
for_,v:=ranges{
sum+=v
}
c<-sum//sendsumtoc
}
funcmain(){
s:=[]int{7,2,8,-9,4,0}
c:=make(chanint)
gosum(s[:len(s)/2],c)
gosum(s[len(s)/2:],c)
x,y:=<-c,<-c//receivefromc
fmt.Println(x,y,x+y)
}
BufferedChannels
make的第二个参数指定缓存的大小：ch:=make(chanint,100)。
通过缓存的使用，可以尽量避免阻塞，提供应用的性能。
Range
for……range语句可以处理Channel。
funcmain(){
gofunc(){
time.Sleep(1*time.Hour)
}()
c:=make(chanint)
gofunc(){
fori:=0;i<10;i=i+1{
c<-i
}
close(c)
}()
fori:=rangec{
fmt.Println(i)
}
fmt.Println("Finished")
}
rangec产生的迭代值为Channel中发送的值，它会一直迭代直到channel被关闭。上面的例子中如果把close(c)注释掉，程序会一直阻塞在for……range那一行。
select
select语句选择一组可能的send操作和receive操作去处理。它类似switch,但是只是用来处理通讯(communication)操作。
它的case可以是send语句，也可以是receive语句，亦或者default。
receive语句可以将值赋值给一个或者两个变量。它必须是一个receive操作。
最多允许有一个defaultcase,它可以放在case列表的任何位置，尽管我们大部分会将它放在最后。
import"fmt"
funcfibonacci(c,quitchanint){
x,y:=0,1
for{
select{
casec<-x:
x,y=y,x+y
case<-quit:
fmt.Println("quit")
return
}
}
}
funcmain(){
c:=make(chanint)
quit:=make(chanint)
gofunc(){
fori:=0;i<10;i++{
fmt.Println(<-c)
}
quit<-0
}()
fibonacci(c,quit)
}
如果有同时多个case去处理,比如同时有多个channel可以接收数据，那么Go会伪随机的选择一个case处理(pseudo-random)。如果没有case需要处理，则会选择default去处理，如果defaultcase存在的情况下。如果没有defaultcase，则select语句会阻塞，直到某个case需要处理。
需要注意的是，nilchannel上的操作会一直被阻塞，如果没有defaultcase,只有nilchannel的select会一直被阻塞。
select语句和switch语句一样，它不是循环，它只会选择一个case来处理，如果想一直处理channel，你可以在外面加一个无限的for循环：
for{
select{
casec<-x:
x,y=y,x+y
case<-quit:
fmt.Println("quit")
return
}
}
timeout
select有很重要的一个应用就是超时处理。因为上面我们提到，如果没有case需要处理，select语句就会一直阻塞着。这时候我们可能就需要一个超时操作，用来处理超时的情况。
下面这个例子我们会在2秒后往channelc1中发送一个数据，但是select设置为1秒超时,因此我们会打印出timeout1,而不是result1。
import"time"
import"fmt"
funcmain(){
c1:=make(chanstring,1)
gofunc(){
time.Sleep(time.Second*2)
c1<-"result1"
}()
select{
caseres:=<-c1:
fmt.Println(res)
case<-time.After(time.Second*1):
fmt.Println("timeout1")
}
}
其实它利用的是time.After方法，它返回一个类型为<-chanTime的单向的channel，在指定的时间发送一个当前时间给返回的channel中。
Timer和Ticker
我们看一下关于时间的两个Channel。
timer是一个定时器，代表未来的一个单一事件，你可以告诉timer你要等待多长时间，它提供一个Channel，在将来的那个时间那个Channel提供了一个时间值。下面的例子中第二行会阻塞2秒钟左右的时间，直到时间到了才会继续执行。
timer1:=time.NewTimer(time.Second*2)
<-timer1.C
fmt.Println("Timer1expired")
当然如果你只是想单纯的等待的话，可以使用time.Sleep来实现。
你还可以使用timer.Stop来停止计时器。
timer2:=time.NewTimer(time.Second)
gofunc(){
<-timer2.C
fmt.Println("Timer2expired")
}()
stop2:=timer2.Stop()
ifstop2{
fmt.Println("Timer2stopped")
}
ticker是一个定时触发的计时器，它会以一个间隔(interval)往Channel发送一个事件(当前时间)，而Channel的接收者可以以固定的时间间隔从Channel中读取事件。下面的例子中ticker每500毫秒触发一次，你可以观察输出的时间。
ticker:=time.NewTicker(time.Millisecond*500)
gofunc(){
fort:=rangeticker.C{
fmt.Println("Tickat",t)
}
}()
类似timer,ticker也可以通过Stop方法来停止。一旦它停止，接收者不再会从channel中接收数据了。
close
内建的close方法可以用来关闭channel。
总结一下channel关闭后sender的receiver操作。
如果channelc已经被关闭,继续往它发送数据会导致panic:sendonclosedchannel:
import"time"
funcmain(){
gofunc(){
time.Sleep(time.Hour)
}()
c:=make(chanint,10)
c<-1
c<-2
close(c)
c<-3
}
但是从这个关闭的channel中不但可以读取出已发送的数据，还可以不断的读取零值:
c:=make(chanint,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(chanint,10)
c<-1
c<-2
close(c)
fori:=rangec{
fmt.Println(i)
}
通过i,ok:=<-c可以查看Channel的状态，判断值是零值还是正常读取的值。
c:=make(chanint,10)
close(c)
i,ok:=<-c
fmt.Printf("%d,%t",i,ok)//0,false
同步
channel可以用在goroutine之间的同步。
下面的例子中maingoroutine通过donechannel等待worker完成任务。worker做完任务后只需往channel发送一个数据就可以通知maingoroutine任务完成。
import(
"fmt"
"time"
)
funcworker(donechanbool){
time.Sleep(time.Second)
//通知任务已完成
done<-true
}
funcmain(){
done:=make(chanbool,1)
goworker(done)
//等待任务完成
<-done
}
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。