讲解一下Go Channel

Channel是Go中的一个核心类型，可以看做是一个管道，通过它并发核心单元就可以发送或者接收数据进行通讯。

它的操作符是箭头

ch 

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

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

ch := make(chan int)

Channel类型

Channel类型的定义格式如下：

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

它包括三种类型的定义。可选的

chan T          // 可以接收和发送类型为 T 的数据
chan

chan

使用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 := 

send语句

send语句用来往Channel中发送数据， 如ch

SendStmt = Channel " Expression .
Channel  = Expression .

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

c := make(chan int)
defer close(c)
go func() { c 

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

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

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

receive 操作符

x, ok := 

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

blocking

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

如官方的例子中x, y :=

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

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 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 case "quit")
           return
       }
   }
}
func main() {
   c := make(chan int)
   quit := make(chan int)
   go func() {
       for i := 0; i 

如果有同时多个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 case "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 := case "timeout 1")
   }
}

其实它利用的是time.After方法，它返回一个类型为

timer1 := time.NewTimer(time.Second * 2)
"Timer 1 expired")

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

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

timer2 := time.NewTimer(time.Second)
go func() {
   "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 

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

c := make(chan int, 10)
c 

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

c := make(chan int, 10)
c for i := range c {
   fmt.Println(i)
}

通过i, ok :=

c := make(chan int, 10)
close(c)
i, ok := "%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
}

以上就是良许教程网为各位朋友分享的Linu系统相关内容。想要了解更多Linux相关知识记得关注公众号“良许Linux”，或扫描下方二维码进行关注，更多干货等着你 ！