Golang Channel 實戰技巧和說明
Channel 的一些實戰說明
關于 close Channel
close Channel 的一些說明
channel 不需要通過 close 來釋放資源，這個是它與 socket、file 等不一樣的地方，對于 channel 而言，唯一需要 close 的就是我們想通過 close 觸發 channel 讀事件。
- close chan 對 chan 阻塞無效，寫了數據不讀，直接 close，還是會阻塞的。
- 如果 channel 已經被關閉，繼續往它發送數據會導致 panic
send on closed channel - closed 的 channel，再次關閉 close 會 panic
- close channel 的推薦使用姿勢是在發送方來執行，因為 channel 的關閉在接收端能感知到，但是發送端感知不到，因此一般只能在發送端主動關閉。而且大部分時候可以不執行 close，只需要讀寫即可。
- 從一個已經 close 的 chan 中讀取數據，是可以讀取的，讀到的數據為 0
- 讀取的 channel 如果被關閉，并不會影響正在讀的數據，它會將所有數據讀取完畢，在讀取完已發送的數據后會返回元素類型的零值(zero value)。
v, ok := <-ch 判斷是否 close
比如 v, ok := <-ch 中 ok 是一個 bool 類型，可以通過它來判斷 channel 是否已經關閉，如果 channel 關閉該值為 false ，此時 v 接收到的是 channel 類型的零值。比如：channel 是傳遞的 int， 那么 v 就是 0 ；如果是結構體，那么 v 就是結構體內部對應字段的零值。
_,ok := <-ch對應的函數是 func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool)，入參block含義是當前goroutine是否可阻塞，當block為false代表的是select操作，不可阻塞當前goroutine的在channel操作，否則是普通操作（即_, ok不在select中）。返回值selected代表當前操作是否成功，主要為select服務，返回received代表是否從channel讀到有效值。它有3種返回值情況：
block為false，即執行select時，如果channel為空，返回(false,false)，代表select操作失敗，沒接收到值。
否則，如果channel已經關閉，并且沒有數據，ep即接收數據的變量設置為零值，返回(true,false)，代表select操作成功，但channel已關閉，沒讀到有效值。
否則，其他讀到有效數據的情況，返回(true,ture)。
優雅判斷是否 close 的封裝
package main
import "fmt"
type T int
func IsClosed(ch <-chan T) bool {
select {
case <-ch:
return true
default:
}
return false
}
func main() {
c := make(chan T)
fmt.Println(IsClosed(c)) // false
close(c)
fmt.Println(IsClosed(c)) // true
}
for-range 讀取 Channel 數據
不管是有緩沖還是無緩沖，都可以使用 for-range 從 channel 中讀取數據，并且這個是一直循環讀取的。
for-range 中的 range 產生的迭代值為 Channel 中發送的值，如果已經這個 channel 已經 close 了，那么首先還會繼續執行，直到所有值被讀取完，然后才會跳出 for 循環，因此，通過 for-range 讀取 chann 數據會比較方便，因為我們只需要讀取數據就行了，不需管他的退出，在 close 之后如果數據讀取完了會自動幫我們退出。如果既沒有 close 也沒有數據可讀，那么就會阻塞到 range 這里，除非有數據產生或者 chan 被關閉了。但是如果 channel 是 nil，讀取會被阻塞，也就是會一直阻塞在 range 位置。
一個示例如下：
ch := make(chan int)
// 一直循環讀取 range 中的迭代值
for v := range ch {
// 得到了 v 這個 chann 中的值
fmt.Println("讀取數據：",v)
}
select 讀寫 Channel 數據
select 的 case 分支里面，可以讀數據，也可以寫數據。最多只允許有一個 default case，它可以放在 case 列表的任何位置，并且沒有任何影響。
select 可以同時處理多個 channel，如果有同時多個 case 分支可以去處理，比如同時有多個 channel 可以接收數據，那么 Go 會偽隨機(pseudo-random)的選擇一個 case 處理。如果沒有 case 需要處理，則會選擇 default 分支去處理。如果沒有 default case，則 select 語句會阻塞，直到某個 case 分支可以處理了。
每次 select 語句的執行，是會掃描完所有的 case 后才確定如何執行，而不是說遇到合適的 case 就直接執行了。
對于 nil channel 上的操作會一直被阻塞，如果沒有 default case，只有 nil channel 的 select 會一直被阻塞。
select 語句和 switch 語句一樣，它不是循環，它只會選擇一個 case 來處理，如果想一直處理channel，你可以在外面加一個無限的 for 循環
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
Channel 的讀寫超時機制【select + timeout】
我們的一般常見場景就是，
當我們從 chann 中進行讀取數據，或者寫入數據的時候，想要快速返回得到是否成功的結果，如果被 chann 阻塞后，需要指定一定的超時時間，然后如果在超時時間內還沒有返回，那么就超時退出，不能一直阻塞在讀寫 chann 的流程中。
Go 的 time 庫里面，提供了 time.NewTimer()、time.After()、time.NewTicker() 等方法，最終都可以通過這些方法來返回或者得到一個 channel，然后向這個 channel 中發送數據，就可以實現定時器的功能。
channel 可以通過 select + timeout 來實現阻塞超時的使用姿勢，超時讀寫的姿勢如下：
// 通過 select 實現讀超時，如果讀 chann 阻塞 timeout 的時間后就會返回
func ReadWithSelect(ch chan int) (x int, err error) {
timeout := time.NewTimer(time.Microsecond * 500)
select {
case x = <-ch:
return x, nil
case <-timeout.C:
return 0, errors.New("read time out")
}
}
// 通過 select 實現寫超時，如果寫 chann 阻塞 timeout 的時間后就會返回
func WriteChWithSelect(ch chan int) error {
timeout := time.NewTimer(time.Microsecond * 500)
select {
case ch <- 1:
return nil
case <-timeout.C:
return errors.New("write time out")
}
}
一個簡單的實操代碼示例
package main
import (
"fmt"
"runtime"
"time"
)
func DoWorker() {
c := make(chan bool, 1)
go func() {
time.Sleep(100 * time.Millisecond) // 等待 100ms 后寫入，和后面的讀超時配合，看超時判斷結果
c <- true
}()
go func() {
timeout := time.NewTimer(time.Millisecond * 105) // 設置 105 ms 超時，如果超時沒有讀取到則 timeout
select {
case x := <-c:
fmt.Printf("read chann:%v\n", x)
case <-timeout.C:
fmt.Println("read timeout")
}
fmt.Printf("over select\n\n")
}()
}
func main() {
fmt.Printf("start main num:%v\n", runtime.NumGoroutine())
go func() {
for {
time.Sleep(1 * time.Second)
fmt.Printf("start go DoWorker\n")
go DoWorker()
}
}()
for {
time.Sleep(4 * time.Second)
fmt.Printf("now main num:%v\n", runtime.NumGoroutine())
}
}
輸出：
start main num:1
start go DoWorker
read chann:true
over select
start go DoWorker
read chann:true
over select
start go DoWorker
read chann:true
over select
TryEnqueue 無阻塞寫 Channel 數據
有些場景，我們期望往緩沖隊列中寫入數據的時候，如果隊列已滿，那么不要進行寫阻塞，而是寫完發現隊列已滿就拋錯，那么我們可以通過如下機制的封裝來實現，原理是通過一個 select 和 一個 default 語句去實現，有一個 default 就不會阻塞了：
var jobChan = make(chan int, 3)
func TryEnqueue(job int) bool {
select {
case jobChan <- job:
fmt.Printf("true\n") // 隊列未滿
return true
default:
fmt.Printf("false\n") // 隊列已滿
return false
}
}
Channel 常見錯誤和根因分析
fatal error: all goroutines are asleep - deadlock 問題解決和優化
參考 go-language-fatal-error-all-goroutines-are-asleep-deadlock，在 main 函數里面，如果要 通過 chann 等待其他子協程的往 chann 中寫入數據，但是并沒有其他子協程寫入或者其他協程沒有寫入就提前退出或者結束了，此時，main goroutine 協程就會等一個永遠不會來的數據，那整個程序就永遠等下去了，這個時候就會報上述錯誤。
fatal error: all goroutines are asleep - deadlock! 異常的示例，在 main 里面，往 chann 中寫超過緩沖數量的數據，這個時候，main 是要期望能夠從有其他協程讀取這些數據的，但是 main 里面并沒有，因此就會報錯：
package main
import "fmt"
func main() {
channel := make(chan string, 2)
fmt.Println("1")
channel <- "h1"
fmt.Println("2")
channel <- "w2"
fmt.Println("3")
channel <- "c3" // 執行到這一步，直接報 error
fmt.Println("...")
msg1 := <-channel
fmt.Println(msg1)
}
優化處理：
package main
import "fmt"
func main() {
channel := make(chan string, 2)
fmt.Println("1")
channel <- "h1"
fmt.Println("2")
channel <- "w2"
fmt.Println("3")
select {
case channel <- "c3":
fmt.Println("ok")
default:
fmt.Println("channel is full !")
}
fmt.Println("...")
msg1 := <-channel
fmt.Println(msg1)
}
最后
這篇文章首發在我微信公眾號【后端系統和架構】中，點擊這里可以去往公眾號查看原文鏈接，如果對你有幫助，歡迎前往關注，更加方便快捷的接收最新優質文章
