gopl-zh.github.com/ch8/ch8-07.md

134 lines
6.3 KiB
Markdown
Raw Normal View History

2016-02-15 03:06:34 +00:00
## 8.7. 基于select的多路复用
2015-12-09 07:45:11 +00:00
2016-02-15 03:06:34 +00:00
下面的程序会进行火箭发射的倒计时。time.Tick函数返回一个channel程序会周期性地像一个节拍器一样向这个channel发送事件。每一个事件的值是一个时间戳不过更有意思的是其传送方式。
2015-12-31 03:21:48 +00:00
2016-01-21 02:39:06 +00:00
<u><i>gopl.io/ch8/countdown1</i></u>
2015-12-30 12:16:09 +00:00
```go
func main() {
2016-01-21 02:39:06 +00:00
fmt.Println("Commencing countdown.")
tick := time.Tick(1 * time.Second)
for countdown := 10; countdown > 0; countdown-- {
fmt.Println(countdown)
2016-09-18 13:26:46 +00:00
<-tick
2016-01-21 02:39:06 +00:00
}
launch()
2015-12-30 12:16:09 +00:00
}
```
2016-02-15 03:06:34 +00:00
现在我们让这个程序支持在倒计时中用户按下return键时直接中断发射流程。首先我们启动一个goroutine这个goroutine会尝试从标准输入中调入一个单独的byte并且如果成功了会向名为abort的channel发送一个值。
2015-12-30 12:16:09 +00:00
2016-01-21 02:39:06 +00:00
<u><i>gopl.io/ch8/countdown2</i></u>
2015-12-30 12:16:09 +00:00
```go
abort := make(chan struct{})
go func() {
2016-01-21 02:39:06 +00:00
os.Stdin.Read(make([]byte, 1)) // read a single byte
abort <- struct{}{}
2015-12-30 12:16:09 +00:00
}()
```
2016-02-15 03:06:34 +00:00
现在每一次计数循环的迭代都需要等待两个channel中的其中一个返回事件了ticker channel当一切正常时(就像NASA jorgon的"nominal",译注:这梗估计我们是不懂了)或者异常时返回的abort事件。我们无法做到从每一个channel中接收信息如果我们这么做的话如果第一个channel中没有事件发过来那么程序就会立刻被阻塞这样我们就无法收到第二个channel中发过来的事件。这时候我们需要多路复用(multiplex)这些操作了为了能够多路复用我们使用了select语句。
2015-12-30 12:16:09 +00:00
```go
select {
case <-ch1:
2016-01-21 02:39:06 +00:00
// ...
2015-12-30 12:16:09 +00:00
case x := <-ch2:
2016-01-21 02:39:06 +00:00
// ...use x...
2015-12-30 12:16:09 +00:00
case ch3 <- y:
2016-01-21 02:39:06 +00:00
// ...
2015-12-30 12:16:09 +00:00
default:
2016-01-21 02:39:06 +00:00
// ...
2015-12-30 12:16:09 +00:00
}
```
2016-02-15 03:06:34 +00:00
上面是select语句的一般形式。和switch语句稍微有点相似也会有几个case和最后的default选择支。每一个case代表一个通信操作(在某个channel上进行发送或者接收)并且会包含一些语句组成的一个语句块。一个接收表达式可能只包含接收表达式自身(译注:不把接收到的值赋值给变量什么的)就像上面的第一个case或者包含在一个简短的变量声明中像第二个case里一样第二种形式让你能够引用接收到的值。
2015-12-31 03:21:48 +00:00
2016-02-15 03:06:34 +00:00
select会等待case中有能够执行的case时去执行。当条件满足时select才会去通信并执行case之后的语句这时候其它通信是不会执行的。一个没有任何case的select语句写作select{},会永远地等待下去。
2015-12-31 03:21:48 +00:00
2016-02-15 03:06:34 +00:00
让我们回到我们的火箭发射程序。time.After函数会立即返回一个channel并起一个新的goroutine在经过特定的时间后向该channel发送一个独立的值。下面的select语句会会一直等待到两个事件中的一个到达无论是abort事件或者一个10秒经过的事件。如果10秒经过了还没有abort事件进入那么火箭就会发射。
2015-12-30 12:16:09 +00:00
```go
func main() {
2016-01-21 02:39:06 +00:00
// ...create abort channel...
fmt.Println("Commencing countdown. Press return to abort.")
select {
case <-time.After(10 * time.Second):
// Do nothing.
case <-abort:
fmt.Println("Launch aborted!")
return
}
launch()
2015-12-31 03:21:48 +00:00
}
2015-12-30 12:16:09 +00:00
```
2016-02-15 03:06:34 +00:00
下面这个例子更微秒。ch这个channel的buffer大小是1所以会交替的为空或为满所以只有一个case可以进行下去无论i是奇数或者偶数它都会打印0 2 4 6 8。
2015-12-30 12:16:09 +00:00
```go
ch := make(chan int, 1)
for i := 0; i < 10; i++ {
2016-01-21 02:39:06 +00:00
select {
case x := <-ch:
fmt.Println(x) // "0" "2" "4" "6" "8"
case ch <- i:
}
2015-12-30 12:16:09 +00:00
}
```
2016-02-15 03:06:34 +00:00
如果多个case同时就绪时select会随机地选择一个执行这样来保证每一个channel都有平等的被select的机会。增加前一个例子的buffer大小会使其输出变得不确定因为当buffer既不为满也不为空时select语句的执行情况就像是抛硬币的行为一样是随机的。
2015-12-31 03:21:48 +00:00
2016-02-15 03:06:34 +00:00
下面让我们的发射程序打印倒计时。这里的select语句会使每次循环迭代等待一秒来执行退出操作。
2015-12-30 12:16:09 +00:00
2016-01-21 02:39:06 +00:00
<u><i>gopl.io/ch8/countdown3</i></u>
2015-12-30 12:16:09 +00:00
```go
func main() {
2016-01-21 02:39:06 +00:00
// ...create abort channel...
fmt.Println("Commencing countdown. Press return to abort.")
tick := time.Tick(1 * time.Second)
for countdown := 10; countdown > 0; countdown-- {
fmt.Println(countdown)
select {
case <-tick:
// Do nothing.
case <-abort:
fmt.Println("Launch aborted!")
return
}
}
launch()
2015-12-30 12:16:09 +00:00
}
```
time.Tick函数表现得好像它创建了一个在循环中调用time.Sleep的goroutine每次被唤醒时发送一个事件。当countdown函数返回时它会停止从tick中接收事件但是ticker这个goroutine还依然存活继续徒劳地尝试向channel中发送值然而这时候已经没有其它的goroutine会从该channel中接收值了--这被称为goroutine泄露(§8.4.4)。
2015-12-31 03:21:48 +00:00
2016-02-15 03:06:34 +00:00
Tick函数挺方便但是只有当程序整个生命周期都需要这个时间时我们使用它才比较合适。否则的话我们应该使用下面的这种模式
2015-12-30 12:16:09 +00:00
```go
ticker := time.NewTicker(1 * time.Second)
2016-01-02 13:17:21 +00:00
<-ticker.C // receive from the ticker's channel
2015-12-30 12:16:09 +00:00
ticker.Stop() // cause the ticker's goroutine to terminate
```
2016-02-15 03:06:34 +00:00
有时候我们希望能够从channel中发送或者接收值并避免因为发送或者接收导致的阻塞尤其是当channel没有准备好写或者读时。select语句就可以实现这样的功能。select会有一个default来设置当其它的操作都不能够马上被处理时程序需要执行哪些逻辑。
2015-12-31 03:21:48 +00:00
2016-02-15 03:06:34 +00:00
下面的select语句会在abort channel中有值时从其中接收值无值时什么都不做。这是一个非阻塞的接收操作反复地做这样的操作叫做“轮询channel”。
2015-12-30 12:16:09 +00:00
```go
select {
case <-abort:
2016-01-21 02:39:06 +00:00
fmt.Printf("Launch aborted!\n")
return
2015-12-30 12:16:09 +00:00
default:
2016-01-21 02:39:06 +00:00
// do nothing
2015-12-30 12:16:09 +00:00
}
```
2016-01-02 13:17:21 +00:00
2016-02-15 03:06:34 +00:00
channel的零值是nil。也许会让你觉得比较奇怪nil的channel有时候也是有一些用处的。因为对一个nil的channel发送和接收操作会永远阻塞在select语句中操作nil的channel永远都不会被select到。
2015-12-31 03:21:48 +00:00
2016-02-15 03:06:34 +00:00
这使得我们可以用nil来激活或者禁用case来达成处理其它输入或输出事件时超时和取消的逻辑。我们会在下一节中看到一个例子。
2015-12-31 03:21:48 +00:00
2016-02-15 03:06:34 +00:00
**练习 8.8** 使用select来改造8.3节中的echo服务器为其增加超时这样服务器可以在客户端10秒中没有任何喊话时自动断开连接。