单向channel:
单向通道可分为发送通道和接收通道。但是无论哪一种单向通道，都不应该出现在变量的声明中，假如初始化了这样一个变量
var uselessChan chan <- int =make(chan <- int,10)
这样一个变量该如何使用呢，这样一个只进不出的通道没有什么实际意义。那么这种单向通道的应用场景在什么地方呢。我们可以用这种变换来约束对通道的使用方式。比如下面的这种声明
func Notify(c chan <- os.Signal, sig… os.Signal)
该函数的第一个参数的类型是发送通道类型。从参数的声明来看，调用它的程序应该传入一个只能发送而不能接收的通道。但是实际上应该传入的双向通道，Go会依据该参数的声明，自动把它转换成一个单向通道。Notify函数中的代码只能向通道c发送数据，而不能从它那里接收数据，在该函数中从通道c接收数据会导致编译错误。但是在函数之外不存在这个约束。
现在对SignalNotifier接口的声明稍作改变，如下：
type SignalNotifier interface{
Notify(sig…os.Signal) <- chan os.Signal
}
现在这个声明放在了函数外面，这种实现方法说明Notify方法的调用只能从作为结果的通道中接收元素值，而不能向其发送元素值。来看一个单向通道的例子
var strChan=make(chan string,3)
var mapChan=make(chan map[string]int,1)
func receive(strChan <- chan string,syncChan1 <- chan struct{},syncChan2 chan <- struct{}){
<-syncChan1
fmt.Println("Received a sync signal and wait a second...[receiver]")
time.Sleep(time.Second)
for{
if elem,ok:=<-strChan;ok{
fmt.Println("Received:",elem,"[receiver]")
}else{
break
}
}
fmt.Println("stopped.[receiver]")
syncChan2 <- struct{}{}
}
func send(strChan chan <- string,syncChan1 chan <- struct{},syncChan2 chan <- struct{}){
for _,elem:=range[]string{"a","b","c","d","e"}{
strChan <- elem
fmt.Println("sent:",elem,"[sender]")
if elem == "c"{
syncChan1 <- struct{}{}
fmt.Println("sent a sync signal.[sender]")
}
}
fmt.Println("wait 2 seconds...[sender]")
time.Sleep(time.Second*2)
close(strChan)
syncChan2 <- struct{}{}
}
func main(){
syncChan1:=make(chan struct{},1)
syncChan2:=make(chan struct{},2)
go receive(strChan,syncChan1,syncChan2)
go send(strChan,syncChan1,syncChan2)
<-syncChan2
<-syncChan2
}
receive函数只能对strChan和syncChan1通道进行接收操作。而send函数只能对这2个通道进行发送操作。区别点在于chan 和 <-的位置。chan <- 表明是接收通道。<- chan表明是发送通道。运行结果如下：
sent: a [sender]
sent: b [sender]
sent: c [sender]
sent a sync signal.[sender]
Received a sync signal and wait a second...[receiver]
sent: d [sender]
Received: a [receiver]
Received: b [receiver]
Received: c [receiver]
Received: d [receiver]
Received: e [receiver]
sent: e [sender]
wait 2 seconds...[sender]
stopped.[receiver]
非缓冲channel
如果在初始化一个通道时将其容量设置为0或者直接忽略对容量的设置。就会使该通道变成一个非缓冲通道。和异步的方式不同，非缓冲通道只能同步的传递元素值
1 向此类通道发送元素值的操作会被阻塞。直到至少有一个针对通道的接收操作进行为止。该接收操作会首先得到元素的副本，然后再唤醒发送方所在的goroutine之后返回。也就是说，这是的接收操作会在对应的发送操作完成之前完成。
2 从此类通道接收元素值的操作会被阻塞，直到至少有一个针对该通道的发送操作进行为止。发送操作会直接把元素值赋值给接收方，然后再唤醒接收方所在的goroutine之后返回。这时的发送操作会在对应的接收操作之前完成。
func main(){
sendingInterval:=time.Second
receptionInterval:=time.Second*2
intChan:=make(chan int,0)
go func(){
var ts0,ts1 int64
for i:=1;i<=5;i++{
intChan <- i
ts1=time.Now().Unix()
if ts0 == 0{
fmt.Println("sent:",i)
}else{
fmt.Println("Sent:",i,"[interval:",ts1-ts0,"] ")
}
ts0=time.Now().Unix()
time.Sleep(sendingInterval)
}
close(intChan)
}()
var ts0,ts1 int64
Loop:
for{
select{
case v,ok:=<-intChan:
if !ok{
break Loop
}
ts1=time.Now().Unix()
if ts0 == 0{
fmt.Println("receive:",v)
}else{
fmt.Println("receive:",v,"[interval:",ts1-ts0,"] ")
}
}
ts0=time.Now().Unix()
time.Sleep(receptionInterval)
}
fmt.Println("End.")
}
运行结果：
sent: 1
receive: 1
receive: 2 [interval: 2 ]
Sent: 2 [interval: 2 ]
Sent: 3 [interval: 2 ]
receive: 3 [interval: 2 ]
receive: 4 [interval: 2 ]
Sent: 4 [interval: 2 ]
receive: 5 [interval: 2 ]
Sent: 5 [interval: 2 ]
End.
可以看到发送操作和接收操作都与receptioninterval的间隔一致。如果把sendingInterval改成time.Second*4. 则结果如下：发送操作和接收操作都与sendingInterval的间隔一致
sent: 1
receive: 1
Sent: 2 [interval: 4 ]
receive: 2 [interval: 4 ]
Sent: 3 [interval: 4 ]
receive: 3 [interval: 4 ]
Sent: 4 [interval: 4 ]
receive: 4 [interval: 4 ]
Sent: 5 [interval: 4 ]
receive: 5 [interval: 4 ]
End.