【Go学习】Golang Channel 详解
【Go学习】Golang Channel 详解Channel是Go中的一个核心类型,你可以把它看成一个管道,通过它并发核心单元就可以发送或者接收数据进行通讯(communication)。 ch <- v // 发送值v到Channel ch中
v := <-ch // 从Channel ch中接收数据,并将数据赋值给v
(箭头的指向就是数据的流向) ch := make(chan int)
Channel类型Channel类型的定义格式如下: ChannelType = ( "chan" | "chan" "<-" | "<-" "chan" ) ElementType
它包括三种类型的定义。可选的 chan T // 可以接收和发送类型为 T 的数据
chan<- float64 // 只可以用来发送 float64 类型的数据
<-chan int // 只可以用来接收 int 类型的数据
chan<- chan int // 等价 chan<- (chan int)
chan<- <-chan int // 等价 chan<- (<-chan int)
<-chan <-chan int // 等价 <-chan (<-chan int)
chan (<-chan int)
使用 make(chan int, 100)
容量(capacity)代表Channel容纳的最多的元素的数量,代表Channel的缓存的大小。 你可以在多个goroutine从/往 一个channel 中 receive/send 数据,不必考虑额外的同步措施。 Channel可以作为一个先入先出(FIFO)的队列,接收的数据和发送的数据的顺序是一致的。 channel的 receive支持 multi-valued assignment,如 v,ok := <-ch
它可以用来检查Channel是否已经被关闭了。 send语句send语句用来往Channel中发送数据, 如 SendStmt = Channel "<-" Expression .
Channel = Expression .
在通讯(communication)开始前channel和expression必选先求值出来(evaluated),比如下面的(3+4)先计算出7然后再发送给channel。 c := make(chan int)
defer close(c)
go func() { c <- 3 + 4 }()
i := <-c
fmt.Println(i)
send被执行前(proceed)通讯(communication)一直被阻塞着。如前所言,无缓存的channel只有在receiver准备好后send才被执行。如果有缓存,并且缓存未满,则send会被执行。 往一个已经被close的channel中继续发送数据会导致run-time panic。 往nil channel中发送数据会一致被阻塞着。 receive 操作符
从一个被close的channel中接收数据不会被阻塞,而是立即返回,接收完已发送的数据后会返回元素类型的零值(zero value)。 如前所述,你可以使用一个额外的返回参数来检查channel是否关闭。 x,ok := <-ch
x,ok = <-ch
var x,ok = <-ch
如果OK 是false,表明接收的x是产生的零值,这个channel被关闭了或者为空。 blocking缺省情况下,发送和接收会一直阻塞着,知道另一方准备好。这种方式可以用来在gororutine中进行同步,而不必使用显示的锁或者条件变量。 package main
import "fmt"
func sum(s []int,c chan int) {
sum := 0
for _,v := range s {
//fmt.Println("v = ",v)
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,<-c // receive from c
fmt.Println(x,y,x+y)
}
运行结果如下: -5 17 12
Buffered Channelsmake的第二个参数指定缓存的大小: 通过缓存的使用,可以尽量避免阻塞,提供应用的性能。 Range
package main
import (
"fmt"
"time"
)
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)
}()
fmt.Println("Befor range")
for i := range c {
fmt.Println(i)
}
fmt.Println("Finished")
}
select
最多允许有一个 package main
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)
}
运行结果如下: 0
1
1
2
3
5
8
13
21
34
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,x+y
case <-quit:
fmt.Println("quit")
return
}
}
timeoutselect有很重要的一个应用就是超时处理。 因为上面我们提到,如果没有case需要处理,select语句就会一直阻塞着。这时候我们可能就需要一个超时操作,用来处理超时的情况。 package main
import (
"fmt"
"time"
)
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")
}
}
运行结果: timeout 1
其实它利用的是time.After方法,它返回一个类型为<-chan Time的单向的channel,在指定的时间发送一个当前时间给返回的channel中。 Timer和Ticker我们看一下关于时间的两个Channel。 timer1 := time.NewTimer(time.Second * 2)
<-timer1.C
fmt.Println("Timer 1 expired")
当然如果你只是想单纯的等待的话,可以使用 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。 总结一下channel关闭后sender的receiver操作。 import "time"
func main() {
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 <- 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(chan int, 10)
c <- 1
c <- 2
close(c)
for i := range c {
fmt.Println(i)
}
通过 c := make(chan int, 10)
close(c)
i,ok := <-c
fmt.Printf("%d,%t",i,ok) //0,false
同步channel可以用在goroutine之间的同步。 package main
import (
"time"
)
func worker(done chan bool) {
time.Sleep(time.Second)
// 通知任务已完成
done <- true
}
func main() {
done := make(chan bool, 1)
go worker(done)
// 等待任务完成
<-done
} (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |