Go语言 Channel <- 箭头操作符 详解

FabioPLA · · 11294 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

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

它的操作符是箭头 <- 。

[plain] view plain copy print?

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

 

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

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

[plain] view plain copy print?

  1. ch := make(chan int)  
ch := make(chan int)

 

 

 

Channel类型

 

Channel类型的定义格式如下:

[plain] view plain copy print?

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

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

 

 

[plain] view plain copy print?

  1. chan T          // 可以接收和发送类型为 T 的数据  
  2. chan<- float64  // 只可以用来发送 float64 类型的数据  
  3. <-chan int      // 只可以用来接收 int 类型的数据  
chan T          // 可以接收和发送类型为 T 的数据
chan<- float64  // 只可以用来发送 float64 类型的数据
<-chan int      // 只可以用来接收 int 类型的数据

<-总是优先和最左边的类型结合。(The <- operator associates with the leftmost chan possible)

[plain] view plain copy print?

  1. chan<- chan int    // 等价 chan<- (chan int)  
  2. chan<- <-chan int  // 等价 chan<- (<-chan int)  
  3. <-chan <-chan int  // 等价 <-chan (<-chan int)  
  4. chan (<-chan int)  
chan<- chan int    // 等价 chan<- (chan int)
chan<- <-chan int  // 等价 chan<- (<-chan int)
<-chan <-chan int  // 等价 <-chan (<-chan int)
chan (<-chan int)

使用make初始化Channel,并且可以设置容量:

[plain] view plain copy print?

  1. make(chan int, 100)  
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,如

[plain] view plain copy print?

  1. v, ok := <-ch  
v, ok := <-ch

 

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

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

[plain] view plain copy print?

  1. SendStmt = Channel "<-" Expression .  
  2. Channel  = Expression .  
SendStmt = Channel "<-" Expression .
Channel  = Expression .

在通讯(communication)开始前channel和expression必选先求值出来(evaluated),比如下面的(3+4)先计算出7然后再发送给channel。

[plain] view plain copy print?

  1. c := make(chan int)  
  2. defer close(c)  
  3. go func() { c <- 3 + 4 }()  
  4. i := <-c  
  5. fmt.Println(i)  
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中发送数据会一致被阻塞着。

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

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

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

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

[plain] view plain copy print?

  1. x, ok := <-ch  
  2. x, ok = <-ch  
  3. var x, ok = <-ch  
x, ok := <-ch
x, ok = <-ch
var x, ok = <-ch

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

 

 

blocking

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

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

[plain] view plain copy print?

  1. import "fmt"  
  2. func sum(s []int, c chan int) {  
  3.     sum := 0  
  4.     for _, v := range s {  
  5.         sum += v  
  6.     }  
  7.     c <- sum // send sum to c  
  8. }  
  9. func main() {  
  10.     s := []int{7, 2, 8, -9, 4, 0}  
  11.     c := make(chan int)  
  12.     go sum(s[:len(s)/2], c)  
  13.     go sum(s[len(s)/2:], c)  
  14.     x, y := <-c, <-c // receive from c  
  15.     fmt.Println(x, y, x+y)  
  16. }  
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。

[plain] view plain copy print?

  1. func main() {  
  2.     go func() {  
  3.         time.Sleep(1 * time.Hour)  
  4.     }()  
  5.     c := make(chan int)  
  6.     go func() {  
  7.         for i := 0; i < 10; i = i + 1 {  
  8.             c <- i  
  9.         }  
  10.         close(c)  
  11.     }()  
  12.     for i := range c {  
  13.         fmt.Println(i)  
  14.     }  
  15.     fmt.Println("Finished")  
  16. }  
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列表的任何位置,尽管我们大部分会将它放在最后。

[plain] view plain copy print?

  1. import "fmt"  
  2. func fibonacci(c, quit chan int) {  
  3.     x, y := 0, 1  
  4.     for {  
  5.         select {  
  6.         case c <- x:  
  7.             x, y = y, x+y  
  8.         case <-quit:  
  9.             fmt.Println("quit")  
  10.             return  
  11.         }  
  12.     }  
  13. }  
  14. func main() {  
  15.     c := make(chan int)  
  16.     quit := make(chan int)  
  17.     go func() {  
  18.         for i := 0; i < 10; i++ {  
  19.             fmt.Println(<-c)  
  20.         }  
  21.         quit <- 0  
  22.     }()  
  23.     fibonacci(c, quit)  
  24. }  
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循环:

[plain] view plain copy print?

  1. for {  
  2.     select {  
  3.     case c <- x:  
  4.         x, y = y, x+y  
  5.     case <-quit:  
  6.         fmt.Println("quit")  
  7.         return  
  8.     }  
  9. }  
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

[plain] view plain copy print?

  1. import "time"  
  2. import "fmt"  
  3. func main() {  
  4.     c1 := make(chan string, 1)  
  5.     go func() {  
  6.         time.Sleep(time.Second * 2)  
  7.         c1 <- "result 1"  
  8.     }()  
  9.     select {  
  10.     case res := <-c1:  
  11.         fmt.Println(res)  
  12.     case <-time.After(time.Second * 1):  
  13.         fmt.Println("timeout 1")  
  14.     }  
  15. }  
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秒钟左右的时间,直到时间到了才会继续执行。

[plain] view plain copy print?

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

 

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

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

[plain] view plain copy print?

  1. timer2 := time.NewTimer(time.Second)  
  2. go func() {  
  3.     <-timer2.C  
  4.     fmt.Println("Timer 2 expired")  
  5. }()  
  6. stop2 := timer2.Stop()  
  7. if stop2 {  
  8.     fmt.Println("Timer 2 stopped")  
  9. }  
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毫秒触发一次,你可以观察输出的时间。

[plain] view plain copy print?

  1. ticker := time.NewTicker(time.Millisecond * 500)  
  2. go func() {  
  3.     for t := range ticker.C {  
  4.         fmt.Println("Tick at", t)  
  5.     }  
  6. }()  
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:

[plain] view plain copy print?

  1. import "time"  
  2. func main() {  
  3.     go func() {  
  4.         time.Sleep(time.Hour)  
  5.     }()  
  6.     c := make(chan int, 10)  
  7.     c <- 1  
  8.     c <- 2  
  9.     close(c)  
  10.     c <- 3  
  11. }  
import "time"
func main() {
	go func() {
		time.Sleep(time.Hour)
	}()
	c := make(chan int, 10)
	c <- 1
	c <- 2
	close(c)
	c <- 3
}

但是从这个关闭的channel中不但可以读取出已发送的数据,还可以不断的读取零值:

[plain] view plain copy print?

  1. c := make(chan int, 10)  
  2. c <- 1  
  3. c <- 2  
  4. close(c)  
  5. fmt.Println(<-c) //1  
  6. fmt.Println(<-c) //2  
  7. fmt.Println(<-c) //0  
  8. fmt.Println(<-c) //0  
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循环会跳出:

[plain] view plain copy print?

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

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

[plain] view plain copy print?

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

 

 

同步

 

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

[plain] view plain copy print?

  1. import (  
  2.     "fmt"  
  3.     "time"  
  4. )  
  5. func worker(done chan bool) {  
  6.     time.Sleep(time.Second)  
  7.     // 通知任务已完成  
  8.     done <- true  
  9. }  
  10. func main() {  
  11.     done := make(chan bool, 1)  
  12.     go worker(done)  
  13.     // 等待任务完成  
  14.     <-done  
  15. }  

有疑问加站长微信联系(非本文作者)

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:701969077

11294 次点击  
加入收藏 微博
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传