Go Channel 详解

1. Channel类型
2. blocking
3. Buffered Channels
4. Range
5. select
   1. timeout
6. Timer和Ticker
7. close
8. 同步
9. 参考资料

Channel是Go中的一个核心类型 你可以把它看成一个管道 通过它并发核心单元就可以发送或者接收数据进行通讯(communication)

它的操作符是箭头 <-

ch <- v  // 发送值v到Channel ch中v := <-ch // 从Channel ch中接收数据 并将数据赋值给v

(箭头的指向就是数据的流向)

就像 map 和 slice 数据类型一样, channel必须先创建再使用:

ch := make(chan int)

Channel类型

Channel类型的定义格式如下：

ChannelType = ( "chan" | "chan" "<-" | "<-" "chan" ) ElementType .

它包括三种类型的定义 可选的<-代表channel的方向 如果没有指定方向 那么Channel就是双向的 既可以接收数据 也可以发送数据

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初始化Channel,并且可以设置容量:

make(chan int, 100)

容量(capacity)代表Channel容纳的最多的元素的数量 代表Channel的缓存的大小
如果没有设置容量 或者容量设置为0, 说明Channel没有缓存 只有sender和receiver都准备好了后它们的通讯(communication)才会发生(Blocking) 如果设置了缓存 就有可能不发生阻塞 只有buffer满了后 send才会阻塞 而只有缓存空了后receive才会阻塞 一个nil channel不会通信

可以通过内建的close方法可以关闭Channel

你可以在多个goroutine从/往 一个channel 中 receive/send 数据, 不必考虑额外的同步措施

Channel可以作为一个先入先出(FIFO)的队列 接收的数据和发送的数据的顺序是一致的

channel的 receive支持 multi-valued assignment 如

v, ok := <-ch

它可以用来检查Channel是否已经被关闭了

1. send语句
   send语句用来往Channel中发送数据 如ch <- 3
   它的定义如下:

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 := <-cfmt.Println(i)

send被执行前(proceed)通讯(communication)一直被阻塞着 如前所言 无缓存的channel只有在receiver准备好后send才被执行 如果有缓存 并且缓存未满 则send会被执行

往一个已经被close的channel中继续发送数据会导致run-time panic

往nil channel中发送数据会一致被阻塞着

1. receive 操作符
   <-ch用来从channel ch中接收数据 这个表达式会一直被block,直到有数据可以接收

从一个nil channel中接收数据会一直被block

从一个被close的channel中接收数据不会被阻塞 而是立即返回 接收完已发送的数据后会返回元素类型的零值(zero value)

如前所述 你可以使用一个额外的返回参数来检查channel是否关闭

x, ok := <-chx, ok = <-chvar x, ok = <-ch

如果OK 是false 表明接收的x是产生的零值 这个channel被关闭了或者为空

blocking

缺省情况下 发送和接收会一直阻塞着 直到另一方准备好 这种方式可以用来在gororutine中进行同步 而不必使用显示的锁或者条件变量

如官方的例子中x, y := <-c, <-c这句会一直等待计算结果发送到channel中

import "fmt"func sum(s []int, c chan int) {    sum := 0    for _, v := range s {        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, y := <-c, <-c // receive from c    fmt.Println(x, y, x+y)}

Buffered Channels

make的第二个参数指定缓存的大小：ch := make(chan int, 100)

通过缓存的使用 可以尽量避免阻塞 提供应用的性能

Range

for …… range语句可以处理Channel

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)    }()    for i := range c {        fmt.Println(i)    }    fmt.Println("Finished")}

range c产生的迭代值为Channel中发送的值 它会一直迭代直到channel被关闭 上面的例子中如果把close(c)注释掉 程序会一直阻塞在for …… range那一行

select

select语句选择一组可能的send操作和receive操作去处理 它类似switch,但是只是用来处理通讯(communication)操作
它的case可以是send语句 也可以是receive语句 亦或者default

receive语句可以将值赋值给一个或者两个变量 它必须是一个receive操作

最多允许有一个default case,它可以放在case列表的任何位置 尽管大部分会将它放在最后

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)}

如果有同时多个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, y = y, x+y    case <-quit:        fmt.Println("quit")        return    }}

timeout

select有很重要的一个应用就是超时处理 因为上面提到 如果没有case需要处理 select语句就会一直阻塞着 这时候可能就需要一个超时操作 用来处理超时的情况
下面这个例子会在2秒后往channel c1中发送一个数据 但是select设置为1秒超时,因此会打印出timeout 1,而不是result 1

import "time"import "fmt"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")  }}

其实它利用的是time.After方法 它返回一个类型为<-chan Time的单向的channel 在指定的时间发送一个当前时间给返回的channel中

Timer和Ticker

看一下关于时间的两个Channel
timer是一个定时器 代表未来的一个单一事件 你可以告诉timer你要等待多长时间 它提供一个Channel 在将来的那个时间那个Channel提供了一个时间值 下面的例子中第二行会阻塞2秒钟左右的时间 直到时间到了才会继续执行

timer1 := time.NewTimer(time.Second * 2)<-timer1.Cfmt.Println("Timer 1 expired")

当然如果你只是想单纯的等待的话 可以使用time.Sleep来实现

你还可以使用timer.Stop来停止计时器

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操作
如果channel c已经被关闭,继续往它发送数据会导致panic: send on closed channel:

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 <- 1c <- 2close(c)fmt.Println(<-c) //1fmt.Println(<-c) //2fmt.Println(<-c) //0fmt.Println(<-c) //0

但是如果通过range读取 channel关闭后for循环会跳出：

c := make(chan int, 10)c <- 1c <- 2close(c)for i := range c {    fmt.Println(i)}

通过i, ok := <-c可以查看Channel的状态 判断值是零值还是正常读取的值

c := make(chan int, 10)close(c)i, ok := <-cfmt.Printf("%d, %t", i, ok) //0, false

同步

channel可以用在goroutine之间的同步
下面的例子中main goroutine通过done channel等待worker完成任务 worker做完任务后只需往channel发送一个数据就可以通知main goroutine任务完成

import (    "fmt"    "time")func worker(done chan bool) {    time.Sleep(time.Second)    // 通知任务已完成    done <- true}func main() {    done := make(chan bool, 1)    go worker(done)    // 等待任务完成    <-done}

来源：http://colobu.com/2016/04/14/Golang-Channels/