超时处理
超时 对于一个连接外部资源，或者其它一些需要花费执行时间的操作的程序而言是很重要的。
得益于通道和 select，在 Go中实现超时操作是简洁而优雅的。
import (
"fmt"
"time"
)
// 例子中，假如我们执行一个外部调用，并在 2 秒后通过通道 c1 返回它的执行结果。
func main() {
c1 := make(chan string, 1)
go func() {
time.Sleep(time.Second * 2)
c1 <- "result 1"
}()
// 这里是使用 select 实现一个超时操作。
// res := <- c1 等待结果，<-Time.After 等待超时时间 1 秒后发送的值。
// 由于 select 默认处理第一个已准备好的接收操作，如果这个操作超过了允许的 1 秒的话，将会执行超时 case。
select {
case res := <-c1:
fmt.Println(res)
case <-time.After(time.Second * 1):
fmt.Println("timeout 1")
}
// 如果我允许一个长一点的超时时间 3 秒，将会成功的从 c2接收到值，并且打印出结果。
c2 := make(chan string, 1)
go func() {
time.Sleep(time.Second * 2)
c2 <- "result 2"
}()
select {
case res := <-c2:
fmt.Println(res)
case <-time.After(time.Second * 3):
fmt.Println("timeout 2")
}
}
输出
timeout 1
result 2
运行这个程序，首先显示运行超时的操作，然后是成功接收的。
使用这个 select 超时方式，需要使用通道传递结果。
非阻塞通道操作
常规的通过通道发送和接收数据是阻塞的。
然而，我们可以使用带一个 default 子句的 select 来实现非阻塞 的发送、接收，甚至是非阻塞的多路 select。
func main() {
messages := make(chan string)
signals := make(chan bool)
// 这里是一个非阻塞接收的例子。如
// 果在 messages 中存在，然后 select 将这个值带入 <-messages case中。
// 如果不是，就直接到 default 分支中。
select {
case msg := <-messages:
fmt.Println("received message ", msg)
default:
fmt.Println("no message received")
}
// 一个非阻塞发送的实现方法和上面一样。
msg := "hi"
select {
case messages <- msg:
fmt.Println("sent message", msg)
default:
fmt.Println("no message sent")
}
// 我们可以在 default 前使用多个 case 子句来实现一个多路的非阻塞的选择器。
// 这里我们试图在 messages和 signals 上同时使用非阻塞的接受操作。
select {
case msg := <-messages:
fmt.Println("received message", msg)
case sig := <-signals:
fmt.Println("received signal", sig)
default:
fmt.Println("no activity")
}
}
输出
no message received
no message sent
no activity
通道的关闭
关闭 一个通道意味着不能再向这个通道发送值了。这个特性可以用来给这个通道的接收方传达工作已经完成的信息。
import (
"fmt"
"time"
)
// 在这个例子中，我们将使用一个 jobs 通道来传递 main() 中 Go协程任务执行的结束信息到一个工作 Go 协程中。
// 当我们没有多余的任务给这个工作 Go 协程时，我们将 close 这个 jobs 通道。
func main() {
jobs := make(chan int, 5)
done := make(chan bool)
// 这是工作 Go 协程。使用 j, more := <- jobs 循环的从jobs 接收数据。
// 在接收的这个特殊的二值形式的值中，如果 jobs 已经关闭了，并且通道中所有的值都已经接收完毕，那么 more 的值将是 false。
// 当我们完成所有的任务时，将使用这个特性通过 done 通道去进行通知。
go func() {
for {
j, more := <-jobs
if more {
fmt.Println("received job", j)
} else {
fmt.Println("received all jobs")
done <- true
return
}
}
}()
// 这里使用 jobs 发送 3 个任务到工作函数中，然后关闭 jobs。
for j := 1; j <= 3; j++ {
jobs <- j
fmt.Println("sent job", j)
time.Sleep(100)
}
close(jobs)
fmt.Println("sent all jobs")
// 我们使用前面学到的通道同步方法等待任务结束。
<-done
}
输出
sent job 1
received job 1
sent job 2
received job 2
sent job 3
received job 3
sent all jobs
received all jobs
如果去掉 time.Sleep(100) 这句
sent job 1
sent job 2
sent job 3
received job 1
received job 2
received job 3
sent all jobs
received all jobs
通道遍历
for 和 range为基本的数据结构提供了迭代的功能。我们也可以使用这个语法来遍历从通道中取得的值。
func main() {
// 我们将遍历在 queue 通道中的两个值。
queue := make(chan string, 2)
queue <- "one"
queue <- "two"
close(queue)
// 这个 range 迭代从 queue 中得到的每个值。
// 因为我们在前面 close 了这个通道，这个迭代会在接收完 2 个值之后结束。
// 如果我们没有 close 它，我们将在这个循环中继续阻塞执行，等待接收第三个值
for elem := range queue {
fmt.Println(elem)
}
}
输出
one
two
一个非空的通道也是可以关闭的，但是通道中剩下的值仍然可以被接收到。