Go select

通過select語句可以監(jiān)聽channel上的數據流動

Golang的select語句類似于UNIX的select()函數的輪詢機制，在UNIX中可通過調用select()函數來監(jiān)控一系列的文件句柄（文件描述符，數量有限），一旦某個文件句柄發(fā)生了I/O動作select()調用就會被返回。該機制也被用于高并發(fā)的Socket服務器程序中。

select來源于網絡I/O模型中的select，本質上I/O多路復用技術，只不過Golang中的select基于的并非網絡而是channel。

select {
  case communication clause:
    statement(s)
  case communication clause:
    statement(s)
  default:
    statement(s)
}

select語句是Golang中的控制結構，類似用于通信的switch語句，也被稱為channel開關。select語句會等待channel準備就緒（收發(fā)操作），以便在不同的case下執(zhí)行。由select開始的一個新的選擇塊，每個選擇條件由case語句來描述。與switch語句相比，select有較多限制，最大的限制在于每個case語句必須是一個I/O操作。

select{
case v1 := <-ch1:
    fmt.Printf("[CH1] received: %v\n", v1)
case v2,ok := <-ch2:
    if ok{
        fmt.Printf("[CH2] received: %v\n", v2)
    }else{
        fmt.Printf("[CH2] closed\n")
    }
case ch3 <-msg:
    fmt.Printf("[CH3] sent: %v\n", msg)
default:
    fmt.Printf("NO Communicating\n")
}

例如：上例select語句擁有四個case子句，前兩個是channel的receive接收操作，第三個是channel的send發(fā)送操作，最后一個default默認操作。當代碼執(zhí)行到select語句時，case子句會按源代碼的順序進行評估，且只評估一次。評估結果會出現下面幾種情況：

  1. 除default外，若只有一個case評估通過則執(zhí)行此case中的語句。
  2. 除default外，若用多個case評估通過則隨機挑選一個執(zhí)行。
  3. 除default外，所有的case評估都不通過，則執(zhí)行default。
  4. 若沒有default則select代碼塊發(fā)生阻塞，直到有一個case通過評估，否則一直阻塞。
  5. 若case中receive接收的是nil則也會發(fā)生阻塞

監(jiān)聽

Golang的select用來監(jiān)聽和channel有關的I/O操作，可監(jiān)聽進入channel時的數據，也可以是用channel發(fā)送值時。當I/O操作發(fā)生時會觸發(fā)相應地動作，因此每個case都必須是一個I/O操作，確切的說應該是一個面向channel的I/O操作。

例如：定時器

ticker1 := time.NewTicker(time.Second * 1)
ticker2 := time.NewTicker(time.Second * 3)

for{
    select{
    case <-ticker1.C:
        fmt.Printf("[1] TICK\n")
    case <-ticker2.C:
        fmt.Printf("[2] TICK\n")
    }
}

在執(zhí)行select語句時，運行時系統(tǒng)會自上而下地判斷每個case中的發(fā)送或接收操作是否可以被立即執(zhí)行，所謂立即執(zhí)行即當前goroutine不會因此操作而被阻塞。

select語句只能用于channel的讀寫操作

例如：使用select來檢測channel是否已滿

ch := make(chan int, 1)
ch<-1

select{
case ch<-2:
    fmt.Printf("send to channel\n")
default:
    fmt.Printf("channel is full\n")
}

特性

  • 每個case都必須是一個channel
  • 所有channel表達式都會被求值
  • 所有被發(fā)送的表達式都會被求值
  • 若任意某個channel可執(zhí)行就執(zhí)行，其它被忽略。

例如：獲取斐波拉茲數列

func fib(ch, quit chan int){
    x,y := 0,1
    for{
        select{
        case ch <- x:
            x,y = y, x+y
        case <-quit:
            fmt.Printf("QUIT\n")
            return
        }
    }
}

func main(){
    ch := make(chan int)
    quit := make(chan int)

    go func(){
        for i:=0; i<10; i++{
            fmt.Println(<-ch)
        }
        quit<-0
    }()

    fib(ch, quit)
}

case

  • select中每個case必須是一個channel操作，要么是發(fā)送要么是接收。

select執(zhí)行過程中必須命中某一case分支，若在遍歷所有case后都沒有命中，則會進入default分支。若沒有default分支則select發(fā)生阻塞，直到某個case可以命中。若一直都沒有命中，則select拋出deadlock死鎖錯誤。

  • 循環(huán)中每次select都會對所有channel表達式求值

例如：通過time.After實現定時器，定時任務可通過done channel停止。

done := make(chan bool, 1)
close(done)
for{
    select{
    case <-time.After(time.Second):
        fmt.Printf("Time after\n")
    case <-done:
        //讀取零值 false
        fmt.Printf("Read done\n")
    }
}
  • 若多個case滿足讀寫條件，select會隨機選擇一個case來執(zhí)行。

select會隨機執(zhí)行一個可運行的case，若沒有case可以運行則阻塞，直到有case可以運行。

select可用于多個channel進行讀寫操作時僅需一次只處理一個的情況。

ch := make(chan int, 1024)
go func(ch chan int){
    for{
        v := <-ch
        fmt.Printf("value = %v\n", v)
    }
}(ch)

ticker := time.NewTicker(time.Second * 1)
for i:=0; i<5; i++{
    select{
    case ch<-i:
    case <-ticker.C:
        fmt.Printf("%d: Ticker\n", i)
    }
    time.Sleep(time.Microsecond * 500)
}

close(ch)
ticker.Stop()

若ticker.C和ch同時滿足讀寫條件時，select會隨機地選擇一個來執(zhí)行，導致看起來一些數據丟了。

  • 對于case條件語句中若存在channel值為nil的讀寫操作，則該分支會被忽略。
var ch chan int

go func(ch chan int){
    ch <- 100
}(ch)

select {
case <-ch:
    fmt.Printf("Channel recieved\n")
}

發(fā)生錯誤：fatal error: all goroutines are asleep - deadlock!

default

select語句會被阻塞，直到其中一個case被執(zhí)行。若select中沒有任何case，它將永遠阻塞，從而導致死鎖。

例如：空select{}引發(fā)死鎖

func main(){
    select {
    
    }
}

對于空的select語句，程序會被阻塞，準確來說是當前goroutine會被阻塞。Golang自帶死鎖檢測機制，發(fā)現當前goroutine再也沒有機會被喚醒時，則會panic。

fatal error: all goroutines are asleep - deadlock!

通過帶default的select實現非阻塞讀寫，用于防止select發(fā)生阻塞。

select{
  default:
}

多個case運行時select會隨機公平地選出一個執(zhí)行，其它不會執(zhí)行。若存在default子句則會執(zhí)行該語句。若沒有default則select阻塞，直到某個通信可以運行。Go不會重新對channel或值進行求值。

當select語句永遠阻塞，沒有其它goroutine寫入此channel時，將導致死鎖。

ch := make(chan int)
select{
case <-ch:
}

fatal error: all goroutines are asleep - deadlock!

若存在默認情況default則不會發(fā)生死鎖deadlock，因為在沒有其它case準備就緒時將執(zhí)行default默認情況。

ch := make(chan int)
select{
case <-ch:
default:
    fmt.Println("default case executed")
}

例如：典型生產者消費者模式

func main(){
    ch1 := make(chan int)
    ch2 := make(chan int)
    //生產者
    go pump1(ch1)
    go pump2(ch2)
    //消費者
    go suck(ch1, ch2)

    time.Sleep(1e9)
}
  • ch1和ch2在無限循環(huán)中通過pump1()和pump2()填充整數
func pump1(ch chan int){
    for i:=0; ; i++{
        ch <- i * 1
    }
}
func pump2(ch chan int){
    for i:=0; ; i++{
        ch <- i * 2
    }
}
  • suck()在無限循環(huán)中輪詢輸入項，通過select語句獲取不同信道的整數并輸出。
func suck(ch1,ch2 chan int){
    for{
        select{
        case v := <-ch1:
            fmt.Printf("[CH1] receive %d\n", v)
        case v := <-ch2:
            fmt.Printf("[CH2] receive %d\n", v)
        default:
            fmt.Printf("NO Communicating\n")
        }
    }
}

選擇select的哪一個case取決于哪個信道接收到了消息。

timeout

當case中的channel始終沒有接收到數據，同時也沒有提供default語句時，select語句整體會發(fā)生阻塞。有時并不希望select一直阻塞下去，此時可手動設置一個超時時間。

func expire(ch chan bool, t int){
    time.Sleep(time.Second * time.Duration(t))
    ch <- true
}

func main(){
    timeout := make(chan bool, 1)
    go expire(timeout, 2)

    ch1 := make(chan string, 1)
    ch2 := make(chan string, 1)
    select{
    case msg1 := <-ch1:
        fmt.Printf("[CH1] received: %s\n", msg1)
    case msg2 := <-ch2:
        fmt.Printf("[CH2] received: %s\n", msg2)
    case <-timeout:
        fmt.Printf("[EXPIRE] exit\n")
    }
}

例如：使用select實現channel的讀取超時機制，不能使用default否則3秒超時未到，就會直接執(zhí)行default。

timeout := make(chan bool, 1)

go func(){
    time.Sleep(time.Second * 3)
    timeout <- true
}()

ch := make(chan int)
select{
case <-ch:
case <-timeout:
    fmt.Printf("TIMEOUT\n")
}

可使用time.After實現超時控制

ch := make(chan int)

select{
case <-ch:
    fmt.Printf("read from ch\n")
case <-time.After(time.Second * time.Duration(3)):
    fmt.Printf("[TIMEOUT] exit\n")
}

for

當for和select結合時，break是無法跳出for之外的，若需break出來需添加標簽使用goto，或break到具體為止。

  • 解決方案1：使用Golang中break的特性在外層for上添加一個標簽
  • 解決方案2：使用goto直接跳出循環(huán)到指定標記位置
  • 對于for中空的select{}也有可能會引起CPU占用過高的問題
ch := make(chan bool)
for i:=0; i<runtime.NumCPU(); i++{
    go func(){
        for{
            select{
            case <-ch:
                break
            default:
            }
        }
    }()
}

time.Sleep(time.Second * 10)
for i:=0; i<runtime.NumCPU(); i++{
    ch<-true
}

一般來說，使用select監(jiān)聽各個case的I/O事件，每個case都是阻塞的。上例中原本希望select在獲取到ch里的數據時立即退出循環(huán)，但由于在for循環(huán)中，第一次讀取ch后僅僅退出了select但并未退出for，因此下次哈希繼續(xù)執(zhí)行select邏輯，此時將永遠是執(zhí)行default，直到ch里讀取到數據。否則會一直在一個死循環(huán)中運行，因此即便只是放到一個goroutine中運行，也會占滿所有的CPU。解決的方式直接把default拿掉，這樣select會一直阻塞在ch通道的I/O上，當ch有數據時就可以隨時響應通道中的信息。

select實現了一種監(jiān)聽模式，通常用在（無限）循環(huán)中，在某中情況下可通過break語句使循環(huán)退出。

ch := make(chan int)
//定時2s
ticker := time.NewTicker(time.Second * 2)
defer ticker.Stop()
//發(fā)送信號
go func(ch chan int){
    time.Sleep(time.Second * 5)
    ch <- 1
}(ch)
//監(jiān)聽I/O
for{
    select{
    case <-ticker.C:
        fmt.Printf("task running...\n")
    case result,ok := <-ch:{
        if ok{
            fmt.Printf("chan number is %v\n", result)
            break
        }
    }
    }
}
fmt.Printf("END\n")

例如：

ch := make(chan int)
quit := make(chan bool)

//寫數據
go func() {
    //循環(huán)寫入
    for i := 0; i < 5; i++ {
        ch <- i
        time.Sleep(time.Second)
    }
    //關閉channel
    close(ch)
    //通知主goroutine推出
    quit <- true
    //退出當前goroutine
    runtime.Goexit()
}()

//主goroutine 讀數據
for {
    select {
    case num := <-ch:
        fmt.Printf("received number is %d\n", num)
    case <-quit:
        fmt.Printf("quit\n")
        //break //跳出select
        return //終止進程
    }
    fmt.Printf("==================\n")
}

多路復用

select是Golang在語言層面提供的多路I/O復用機制，它可檢測多個channel是否ready（是否可讀或可寫）。

select是如何實現多路復用的，為什么沒有在第一個channel操作時阻塞，從而導致后面的case都執(zhí)行不了。

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內容

  • Go 的select語句是一種僅能用于channl發(fā)送和接收消息的專用語句，此語句運行期間是阻塞的；當select...
    菜剛RyuGou閱讀 1,408評論 0贊 11
  • golang 的 select 的功能和 select, poll, epoll 相似， 就是監(jiān)聽 IO 操作，當...
    builderfa閱讀 550評論 0贊 0
  • select 語句的行為 select就是用來監(jiān)聽和channel有關的IO操作 上面這段代碼中，select 語...
    Jaycee88閱讀 343評論 1贊 0
  • Go里面的一個關鍵字，用于監(jiān)聽channel上的數據流動。select語句里面的每條case語句必須是一個IO操作...
    騎蝸上高速閱讀 321評論 0贊 0
  • 下面的例子很好的反映了select、case、協程的運作，實現的功能是：隨機打印1或者2，到達超時后停止。 實現方...
    JoyHair閱讀 3,690評論 0贊 1

友情鏈接更多精彩內容