阻塞与流程控制

通常在并发程序中要尽力避免阻塞式操作，但有时又需要让代码暂时处于阻塞状态，以等待某种条件、信号或数据，然后再继续运行。

对于无缓冲通道，试图从无人写入的通道中读取，或者向无人读取的通道中写入，都会引起阻塞。

重点：利用无缓冲通道的阻塞I/O，可以很容易地在异步执行的多个Goroutine之间构建同步化的流程控制。

// 基于通道的流程控制
// 试图从无人写入的通道中读取，或者向无人读取的通道中写入，都会引起阻塞，利用
// 这一特性可在多"线程"之间建立某种"停——等"机制
// 在下例中，模拟了一个电子时间，每隔1s更新显示一次时间。在父线程中先于子线程写入而读取，产生阻塞；子线程先于父现场而写入，也会产生阻塞。
package mainimport ("fmt""time"
)func clock(c chan string) {ticker := time.NewTicker(time.Second) // 定时器，周期为1sfor { // 死循环t := <-ticker.C 	// C是一个chnnel,每间隔一个定时周期，可以从通道内// 度取1个时间信息// 格式化时间展示格式并写入传入函数的channel cc <- t.Format("02 Jan 2006 15:04:05")	}
}func main() {c := make(chan string)go clock(c)for {message := <-cfmt.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 := <-cc <- "Hello World!"
}

通过指定通道型参数的读写权限，有助于确保通道中数据的完整性，同时指定程序的哪部分可向通道发送数据，哪部分又能从通道接收数据。

select语句

在并发式编程中，经常需要利用多个通道，同时与多个Goroutine建立通信。

顺序遍历来自多个通道的消息显然并非好的设计，因为仅一个通道的阻塞就会影响对其它所有通道消息的处理，例如：

for {msg1 := <-c1 // fmt.Println(msg1)msg2 := <-c2 // fmt.Println(msg2)
}

假设负责向c1通道写入数据的"子线程"由于某种原因发生了阻塞，没能及时地写入数据，"父线程"将阻塞在从c1通道读取数据的语句，这时负责向c2通道写入数据的另外一个"子线程"将因为c2通道无人读取而发生写阻塞。这种因为一个"线程"发生阻塞导致所有"线程"都跟着一起阻塞的运行模式，显然有悖于并发式编程的设计初衷，应当着意避免。

// 多通道I/O(错误实例：顺序遍历)
// 顺序遍历来自多个通道的消息显然并非好的设计，因为
// 仅一个通道的阻塞就会影响对其它所有通道消息的处理
package mainimport ("fmt""time"
)func proc(c chan rune, ch rune,	// rune类型，unicode编码等价于int32ms 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 := <-c1fmt.Printf("%c", ch)ch = <-c2fmt.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 mainimport ("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): // 触发超时，1sfmt.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 := false

for !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 := falsefor !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!