select 实例
Go 语言选择（select）可以等待多个通道操作。将 goroutine 和 channel 与 select 结合是 Go 语言的一个强大功能。看起来可能和 switch 相似，但是并不是。
对于这个示例，将选择两个通道。
每个通道将在一段时间后开始接收值，以模拟阻塞在并发 goroutines 中执行 RPC 操作。我们将使用 select 同时等待这两个值，在每个值达到时打印它们。
执行实例程序得到的值是 one ， 然后是 two 。注意，总执行时间只有 1-2 秒 Sleeps 同时执行。
package main
import (
"fmt"
"time"
)
func main(){
// channel
c1 := make (chan string)
c2 := make (chan string)
go func(){
time.Sleep(time.Second * 1)
c1 <- "ONE"
}()
go func(){
time.Sleep(time.Second * 2)
c2 <- "TWO"
}()
for i := 0 ; i < 2 ; i ++ {
select {
case msg1 := <-c1:
fmt.Println("received~one",msg1)
case msg2 := <-c2:
fmt.Println("received~two",msg2)
}
}
}
超时（timeouts）实例
超时对于连接到外部资源或在不需要绑定执行时间的程序很重要。在 Go 编程中由于使用了通道和选择 （select），实现超时是很容易和优雅的。
在这个示例中，假设正在执行一个外部调用，2秒后在通道 C1 上返回其结果。
这里是 select 实现超时。res := <-c1 等待结果和 <-Time 。等待在超时 1 秒后发送一个值。由于选择继续准备好第一个接收，如果超时超过允许的 1 秒，则将按照超时情况处理。
如果允许更长的超时，如： 3s ，那么从 c2 的接收将成功，这里将会打印。
运行此程序显示第一个操作超时和第二个操作超时。
使用此选择超时模式需要通过通道传达结果。这是一个好主意，因为其他重要的 Go 功能是基于渠道和 Select。现在看看下面的两个例子：计时器和ticker 。
package main
import (
"time"
"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")
}
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("timeout2")
}
}
非阻塞通道操作实例
通道的基本发送和接受都阻塞。但是，可以使用 select 和 default 子句来实现非阻塞发送，接收，甚至非阻塞多路选择( select )。
这里会是一个非阻塞接收。如果消息上有可用的值，则选择将使用该值的 <-message 。如果不是，它会立即采取默认情况。
可以使用多个上面的默认子句来实现多路非阻塞选择（select）。这里尝试对消息(message) 和信号（signals） 的非阻塞接收。
package main
import (
"fmt"
"time"
)
func main(){
messages := make(chan string)
signals := make(chan bool)
go func() {
messages <- "test"
}()
time.Sleep(time.Second * 1)
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")
}
select {
case msg := <- messages:
fmt.Println("received message",msg)
case sig := <-signals:
fmt.Println("received signals",sig)
default:
fmt.Println("no activity")
}
}
go 关闭通道实例
关闭通道表示不会再发送值。这对于将完成通讯到通道的接收器是很有用的。
在这个例子中，我们将使用一个作业通道来完成从 main goroutine 到 worker goroutine 的工作。当没有更多的工作时，则将关闭工作通道。
这里是工作程序 goroutine。它反复从j的工作接收 more := <- jobs 。在这种特殊的 2 值形式的接收中。如果作业已关闭并且接受到的通道中的所有值，则 more 的值将为 false。当已经完成了所有的工作时，使用这个通知。
这会通过作业通道向工作线程发送 3 个作业，然后关闭它。
package main
import "fmt"
func main(){
jobs := make(chan int,5)
done := make(chan bool)
go func() {
for {
j , more := <- jobs
if more{
fmt.Println("received job",j)
}else {
fmt.Println("received all jobs")
done <- true
return
}
}
}()
for j:=1 ; j<= 3 ; j++{
jobs <- j
fmt.Println("send job",j)
}
//关闭通道
close(jobs)
fmt.Println("send all jobs")
//
fmt.Println(<-done)
}
以上例程中实际输出的时候遇到输出为以下样子：
"D:\Program\Gogland 172.3757.2\bin\runnerw.exe" C:\Go\bin\go.exe run C:/Go/MyGo/src/lesson5_select/close_chan.go
send job 1
send job 2
received job 1
received job 2
received job 3
send job 3
send all jobs
received all jobs
true
个人猜想是因为 goroutine 中执行的线程调度的时候快于 主要 routine。所以出现以上输出，但是就是实际执行过程的时候一定是接收到发送过后再输出。
go 通道范围实例
在前面的例子中，我们已经看到了 for 和 range 语句如何为基于数据结构提供迭代。还可以使用此语法对从通道接收的值进行迭代。
此范围在从队列中接收到的每个元素上进行迭代。因为关闭了上面的通道，迭代在接收到 2 个元素后终止。
这个示例还可以关闭非空信道，但仍接收剩余值。
package main
import "fmt"
func main(){
//存放两个值在通道中
queue := make(chan string,2)
queue <- "one"
queue <- "two"
close(queue)
for elem:=range queue{
fmt.Println(elem)
}
}
输出结果如下：
"D:\Program\Gogland 172.3757.2\bin\runnerw.exe" C:\Go\bin\go.exe run C:/Go/MyGo/src/lesson5_select/chan_range.go
one
two
go 计时器实例
我们经常想在将来某个时间点执行Go 代码，或者在某个时间间隔重复执行。 Go 内置计时器和自动接收器功能使这两项任务变得容易。我们先看看定时器，然后再看看行情。
定时器代表未来的一个事件。可告诉定时器您想要等待多长时间，它提供一个通道，得到通知的时候执行相应程序。在这个示例中，计时器将等待2 秒钟。
<-timer1.C 阻塞定时器的通道 C ，直到它发送一个指示定时器超时的值。
如果只是想等待，可以使用 time.Sleep 。定时器可能起作用的一个原因是在定时器到期之前取消定时器。
第一个定时器将在启动程序后 2s 后过期，但第二个定时器应该在它到期之前停止。
package main
import (
"time"
"fmt"
)
func main(){
timer1 := time.NewTimer(time.Second * 2)
<-timer1.C
fmt.Println("Timer 1 expired")
timer2 := time.NewTimer(time.Second)
go func() {
<- timer2.C
fmt.Println("Timer 2 expired")
}()
stop2 := timer2.Stop()
if stop2{
fmt.Println("Timer 2 stoped")
}
}
