go select的用法

Posted on by

golang中的select語句格式如下

select {
    case <-ch1:
        // 如果從 ch1 信道成功接收數據，則執行該分支代碼
    case ch2 <- 1:
        // 如果成功向 ch2 信道成功發送數據，則執行該分支代碼
    default:
        // 如果上面都沒有成功，則進入 default 分支處理流程
}

可以看到select的語法結構有點類似於switch，但又有些不同。

select裡的case後面並不帶判斷條件，而是一個信道的操作，不同於switch裡的case，對於從其它語言轉過來的開發者來說有些需要特別註意的地方。

golang 的 select 就是監聽 IO 操作，當 IO 操作發生時，觸發相應的動作每個case語句裡必須是一個IO操作，確切的說，應該是一個面向channel的IO操作。

註：Go 語言的 select 語句借鑒自 Unix 的 select() 函數，在 Unix 中，可以通過調用 select() 函數來監控一系列的文件句柄，一旦其中一個文件句柄發生瞭 IO 動作，該 select() 調用就會被返回（C 語言中就是這麼做的），後來該機制也被用於實現高並發的 Socket 服務器程序。Go 語言直接在語言級別支持 select關鍵字，用於處理並發編程中通道之間異步 IO 通信問題。

註意：如果 ch1 或者 ch2 信道都阻塞的話，就會立即進入 default 分支，並不會阻塞。但是如果沒有 default 語句，則會阻塞直到某個信道操作成功為止。

知識點

  • select語句隻能用於信道的讀寫操作
  • select中的case條件(非阻塞)是並發執行的，select會選擇先操作成功的那個case條件去執行，如果多個同時返回，則隨機選擇一個執行，此時將無法保證執行順序。對於阻塞的case語句會直到其中有信道可以操作，如果有多個信道可操作，會隨機選擇其中一個 case 執行
  • 對於case條件語句中，如果存在信道值為nil的讀寫操作，則該分支將被忽略，可以理解為從select語句中刪除瞭這個case語句
  • 如果有超時條件語句，判斷邏輯為如果在這個時間段內一直沒有滿足條件的case,則執行這個超時case。如果此段時間內出現瞭可操作的case,則直接執行這個case。一般用超時語句代替瞭default語句
  • 對於空的select{}，會引起死鎖
  • 對於for中的select{}, 也有可能會引起cpu占用過高的問題

下面列出每種情況的示例代碼

1. select語句隻能用於信道的讀寫操作

package main
 
import "fmt"
 
func main() {
    size := 10
    ch := make(chan int, size)
    for i := 0; i < size; i++ {
        ch <- 1
    }
 
    ch2 := make(chan int, size)
    for i := 0; i < size; i++ {
        ch2 <- 2
    }
 
    ch3 := make(chan int, 1)
 
    select {
    case 3 == 3:
        fmt.Println("equal")
    case v := <-ch:
        fmt.Print(v)
    case b := <-ch2:
        fmt.Print(b)
    case ch3 <- 10:
        fmt.Print("write")
    default:
        fmt.Println("none")
    }
}

語句會報錯

prog.go:20:9: 3 == 3 evaluated but not used
prog.go:20:9: select case must be receive, send or assign recv<br>從錯誤信息裡我們證實瞭第一點。

2. select中的case語句是隨機執行的

package main
 
import "fmt"
 
func main() {
    size := 10
    ch := make(chan int, size)
    for i := 0; i < size; i++ {
        ch <- 1
    }
 
    ch2 := make(chan int, size)
    for i := 0; i < size; i++ {
        ch2 <- 2
    }
 
    ch3 := make(chan int, 1)
 
    select {
    case v := <-ch:
        fmt.Print(v)
    case b := <-ch2:
        fmt.Print(b)
    case ch3 <- 10:
        fmt.Print("write")
    default:
        fmt.Println("none")
    }
}

　　多次執行的話，會隨機輸出不同的值，分別為1,2,write。這是因為ch和ch2是並發執行會同時返回數據，所以會隨機選擇一個case執行，。但永遠不會執行default語句，因為上面的三個case都是可以操作的信道。

3. 對於case條件語句中，如果存在通道值為nil的讀寫操作，則該分支將被忽略

package main
 
import "fmt"
func main() {
    var ch chan int
    // ch = make(chan int)
     
    go func(c chan int) {
        c <- 100
    }(ch)
 
    select {
    case <-ch:
        fmt.Print("ok")
 
    }
}

報錯

fatal error: all goroutines are asleep – deadlock!
 
goroutine 1 [select (no cases)]:
main.main()
    /tmp/sandbox488456896/main.go:14 +0x60
 
goroutine 5 [chan send (nil chan)]:
main.main.func1(0x0, 0x1043a070)
    /tmp/sandbox488456896/main.go:10 +0x40
created by main.main
    /tmp/sandbox488456896/main.go:9 +0x40

可以看到 “goroutine 1 [select (no cases)]” ，雖然寫瞭case條件，但操作的是nil通道，被優化掉瞭。
要解決這個問題，隻能使用make()進行初始化才可以。　　

4. 超時用法

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    ch := make(chan int)
    go func(c chan int) {
        // 修改時間後,再查看執行結果
        time.Sleep(time.Second * 1)
        ch <- 1
    }(ch)
 
    select {
    case v := <-ch:
        fmt.Print(v)
    case <-time.After(2 * time.Second): // 等待 2s
        fmt.Println("no case ok")
    }
    time.Sleep(time.Second * 10)
}

我們通過修改上面的時等待時間可以看到，如果等待時間超出<2秒，則輸出1，否則打印“no case ok”　　

5. 空select{}

package main
 
func main() {
    select {}
}
goroutine 1 [select (no cases)]:
main.main()
/root/project/practice/mytest/main.go:10 +0x20
exit status 2
直接死鎖

6. for中的select 引起的CPU過高的問題

package main 
import (
    "runtime"
    "time"
) 
func main() {
    quit := make(chan bool)
    for i := 0; i != runtime.NumCPU(); i++ {
        go func() {
            for {
                select {
                case <-quit:
                    break
                default:
                }
            }
        }()
    }
    time.Sleep(time.Second * 15)
    for i := 0; i != runtime.NumCPU(); i++ {
        quit <- true
    }
}

上面這段代碼會把所有CPU都跑滿，原因就就在select的用法上。

一般來說，我們用select監聽各個case的IO事件，每個case都是阻塞的。上面的例子中，我們希望select在獲取到quit通道裡面的數據時立即退出循環，但由於他在for{}裡面，在第一次讀取quit後，僅僅退出瞭select{}，並未退出for，所以下次還會繼續執行select{}邏輯，此時永遠是執行default，直到quit通道裡讀到數據，否則會一直在一個死循環中運行，即使放到一個goroutine裡運行，也是會占滿所有的CPU。

解決方法就是把default去掉即可，這樣select就會一直阻塞在quit通道的IO上， 當quit有數據時，就能夠隨時響應通道中的信息。

補充：7. 使用 select 切換協程

從不同的並發執行的協程中獲取值可以通過關鍵字select來完成，它和switch控制語句非常相似也被稱作通信開關；它的行為像是“你準備好瞭嗎”的輪詢機制；select監聽進入通道的數據，也可以是用通道發送值的時候。

select {
case u:= <- ch1:
        ...
case v:= <- ch2:
        ...
        ...
default: // no value ready to be received
        ...
}

default 語句是可選的；fallthrough 行為，和普通的 switch 相似，是不允許的。在任何一個 case 中執行 break 或者 return，select 就結束瞭。

select 做的就是：
選擇處理列出的多個通信情況中的一個。
如果都阻塞瞭，會等待直到其中一個可以處理
如果多個可以處理，隨機選擇一個
如果沒有通道操作可以處理並且寫瞭 default 語句，它就會執行：default 永遠是可運行的（這就是準備好瞭，可以執行）。

在 select 中使用發送操作並且有 default 可以確保發送不被阻塞！如果沒有 default，select 就會一直阻塞。
select 語句實現瞭一種監聽模式，通常用在（無限）循環中；在某種情況下，通過 break 語句使循環退出。
在程序 goroutine_select.go 中有 2 個通道 ch1 和 ch2，三個協程 pump1()、pump2() 和 suck()。這是一個典型的生產者消費者模式。在無限循環中，ch1 和 ch2 通過 pump1() 和 pump2() 填充整數；suck() 也是在無限循環中輪詢輸入的，通過 select 語句獲取 ch1 和 ch2 的整數並輸出。選擇哪一個 case 取決於哪一個通道收到瞭信息。程序在 main 執行 1 秒後結束。

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)

    go pump1(ch1)
    go pump2(ch2)
    go suck(ch1, ch2)

    time.Sleep(1e9)
}

func pump1(ch chan int) {
    for i := 0; ; i++ {
        ch <- i * 2
    }
}

func pump2(ch chan int) {
    for i := 0; ; i++ {
        ch <- i + 5
    }
}

func suck(ch1, ch2 chan int) {
    for {
        select {
        case v := <-ch1:
            fmt.Printf("Received on channel 1: %d\n", v)
        case v := <-ch2:
            fmt.Printf("Received on channel 2: %d\n", v)
        }
    }
}

輸出：

Received on channel 2: 5
Received on channel 2: 6
Received on channel 1: 0
Received on channel 2: 7
Received on channel 2: 8
Received on channel 2: 9
Received on channel 2: 10
Received on channel 1: 2
Received on channel 2: 11
…
Received on channel 2: 47404
Received on channel 1: 94346
Received on channel 1: 94348

一秒內的輸出非常驚人，如果我們給它計數（goroutine_select2.go），得到瞭 90000 個左右的數字。

到此這篇關於go select的用法的文章就介紹到這瞭,更多相關go select內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：