阻塞与流程控制
通常在并发程序中要尽力避免阻塞式操作，但有时又需要让代码暂时处于阻塞状态，以等待某种条件、信号或数据，然后再继续运行。
对于无缓冲通道，试图从无人写入的通道中读取，或者向无人读取的通道中写入，都会引起阻塞。
重点：利用无缓冲通道的阻塞I/O，可以很容易地在异步执行的多个Goroutine之间构建同步化的流程控制。
// 基于通道的流程控制
// 试图从无人写入的通道中读取，或者向无人读取的通道中写入，都会引起阻塞，利用
// 这一特性可在多"线程"之间建立某种"停——等"机制
// 在下例中，模拟了一个电子时间，每隔1s更新显示一次时间。在父线程中先于子线程写入而读取，产生阻塞；子线程先于父现场而写入，也会产生阻塞。
package main
import (
"fmt"
"time"
)
func clock(c chan string) {
ticker := time.NewTicker(time.Second) // 定时器，周期为1s
for { // 死循环
t := <-ticker.C // C是一个chnnel,每间隔一个定时周期，可以从通道内
// 度取1个时间信息
// 格式化时间展示格式并写入传入函数的channel c
c <- t.Format("02 Jan 2006 15:04:05")
}
}
func main() {
c := make(chan string)
go clock(c)
for {
message := <-c
fmt.Printf("\r%v", message)
}
}通道型函数参数（只读、只写、可读可写）
可将通道作为参数传递给函数，并在其类型中指明该通道型参数是只读的、只写的，还是既可读又可写的。
func channelReader(c <-chan string) { // 只读通道
message := <-c
}
func channelWriter(c chan<- string) { // 只写通道
c <- "Hello World!"
}
func channelReaderAndWriter(c chan string) { // 可读写通道
message := <-c
c <- "Hello World!"
}通过指定通道型参数的读写权限，有助于确保通道中数据的完整性，同时指定程序的哪部分可向通道发送数据，哪部分又能从通道接收数据。
select语句
在并发式编程中，经常需要利用多个通道，同时与多个Goroutine建立通信。
顺序遍历来自多个通道的消息显然并非好的设计，因为仅一个通道的阻塞就会影响对其它所有通道消息的处理，例如：
for {
msg1 := <-c1 //
fmt.Println(msg1)
msg2 := <-c2 //
fmt.Println(msg2)
}假设负责向c1通道写入数据的"子线程"由于某种原因发生了阻塞，没能及时地写入数据，"父线程"将阻塞在从c1通道读取数据的语句，这时负责向c2通道写入数据的另外一个"子线程"将因为c2通道无人读取而发生写阻塞。这种因为一个"线程"发生阻塞导致所有"线程"都跟着一起阻塞的运行模式，显然有悖于并发式编程的设计初衷，应当着意避免。
// 多通道I/O(错误实例：顺序遍历)
// 顺序遍历来自多个通道的消息显然并非好的设计，因为
// 仅一个通道的阻塞就会影响对其它所有通道消息的处理
package main
import (
"fmt"
"time"
)
func proc(c chan rune, ch rune, // rune类型，unicode编码等价于int32
ms time.Duration) {
for {
c <- ch
time.Sleep(ms * time.Millisecond)
}
}
func main() {
c1 := make(chan rune)
c2 := make(chan rune)
go proc(c1, '-', 100) // 初衷：每100ms，打印1个-
go proc(c2, '+', 500) // 初衷：每500ms，打印1个+
for {
ch := <-c1
fmt.Printf("%c", ch)
ch = <-c2
fmt.Printf("%c", ch)
}
}
// 打印输出：
// +-+-+-+-+-+-+-+-+-+-+-+-+
// 实际情况，两个现场都是按照500ms的时间间隔来打印的，其原因在于两个channel/// 的读取数据都发生在同一个线程中，且二者是顺序执行的关系，c2阻塞时，c1也无法
// 执行。select语句为多个通道创建了一系列接收者，哪个通道先有消息被写入就先接收哪个通道。
for {
select {
case message := <-c1: //
fmt.Println(message)
case message := <-c2: //
fmt.Println(message)
}
}"父线程"中的select语句以阻塞方式，同时监视连接着多个"子线程"的多个通道，无论哪个"子线程"向其所持有的通道写入了数据，select语句都会立即有所察觉，并根据先到先得的原则，匹配到与发生写入动作的通道相对应的case分支，读取该通道中的数据。
// 多通道选择 (前一示例的正确处理形式)
// select语句为多个通道创建了一系列接收者，
// 哪个通道先有消息被写入就先接收哪个通道
package main
import (
"fmt"
"time"
)
func proc(c chan rune, ch rune,
ms time.Duration) {
for {
c <- ch
time.Sleep(ms * time.Millisecond)
}
}
func main() {
c1 := make(chan rune)
c2 := make(chan rune)
go proc(c1, '-', 100)
go proc(c2, '+', 500)
for {
select {
case ch := <-c1:
fmt.Printf("%c", ch)
case ch := <-c2:
fmt.Printf("%c", ch)
}
}
}
// 打印输出：
// +-----+-----+-----+-----+ 要想从多个通道中以最及时的方式接收并处理消息，select语句是个不错的选择，但如果所有的通道都没有消息呢？
- select语句将会长时间甚至永远处于阻塞状态，这对于并发式编程同样是不利的。
可以设置一个超时时间，让select语句于指定的时间后解除阻塞，继续运行。
注：time包的After函数，其参数为某一时间值，该函数会返回1个channel。这个channel会在指定的参数时间之后，会有消息写入（一个时间消息）。
for {
select {
case message := <-c1:
fmt.Println(message)
case message := <-c2:
fmt.Println(message)
case <-time.After(time.Second): // 触发超时
fmt.Println("反正也没消息，不如摸会鱼吧……╮(╯ω╰)╭ ")
}
}// 永久等待
// 若通道长时间无人写入，针对该
// 通道的select语句将会一直阻塞
package main
import (
"fmt"
"time"
)
func proc(c chan rune, ch rune,
ms time.Duration) {
for i := 0; ; { // 仅执行10次写入操作
if i < 10 {
c <- ch
i++
}
time.Sleep(ms * time.Millisecond)
}
}
func main() {
c1 := make(chan rune)
c2 := make(chan rune)
go proc(c1, '-', 100) // 写10次-
go proc(c2, '+', 500) // 写10次+
for {
select {
case ch := <-c1:
fmt.Printf("%c", ch)
case ch := <-c2:
fmt.Printf("%c", ch)
}
}
}
// 打印输出：
// +-----+-----++++++++
// 主线程在读取10个-与10个+后，就处于了永久阻塞状态。// 等待超时
// 使用超时时间，可让select语句在长时间收不到消息的
// 情况下不至于一直阻塞，可利用这段时间执行空闲处理
package main
import (
"fmt"
"time"
)
func proc(c chan rune, ch rune,
ms time.Duration) {
for i := 0; ; {
if i < 10 {
c <- ch
i++
}
time.Sleep(ms * time.Millisecond)
}
}
func main() {
c1 := make(chan rune)
c2 := make(chan rune)
go proc(c1, '-', 100)
go proc(c2, '+', 500)
for {
select {
case c := <-c1:
fmt.Printf("%c", c)
case c := <-c2:
fmt.Printf("%c", c)
case t := <-time.After(time.Second): // 触发超时，1s
fmt.Printf("\n%s> Timeout!",
t.Format("2006/01/02 15:04:05"))
// ……还应有相应的退出循环，退出通道等善后操作
}
}
}
// 打印输出：
// +-----+-----++++++++
// 2020/01/04 16:45:57> Timeout!退出通道
通过设置超时时间，固然可以解除处于阻塞状态的select语句，但有时解除阻塞的条件也许并不是时间。
为select语句添加一个退出通道，通过向退出通道发送消息解除select阻塞。
stop := make(chan bool)
go func() {
if 消息循环可以退出了 {
stop <- true
}
}()
escape := falsefor !escape { // 消息循环
select {
... // 处理各种消息
case <-stop:
escape = true
}
} // 退出通道（给电子时钟的实例添加退出通道操作）
// 为select语句添加退出通道，向退出通道发送消息以结束select循环
package main
import (
"fmt"
"time"
)
func clock(channel chan string) {
ticker := time.NewTicker(time.Second)
for {
t := <-ticker.C
channel <- t.Format(
"02 Jan 2006 15:04:05")
}
}
func main() {
work := make(chan string)
stop := make(chan bool)
go clock(work)
go func() {
time.Sleep(10 * time.Second) // 10s后关闭消息循环
stop <- true
}()
escape := false
for !escape {
select {
case message := <-work:
fmt.Printf("\r%v", message)
case <-stop: // 退出通道
escape = true
}
}
fmt.Println("\nTime's up!")
}
// 打印输出：
// 04 Feb 2020 18:00:48
// Time's up! 
