golang中的select語句格式如下

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

可以看到select的語法結(jié)構(gòu)有點類似于switch，但又有些不同。

select里的case后面并不帶判斷條件，而是一個信道的操作，不同于switch里的case，對于從其它語言轉(zhuǎn)過來的開發(fā)者來說有些需要特別注意的地方。

golang 的 select 就是監(jiān)聽 IO 操作，當(dāng) IO 操作發(fā)生時，觸發(fā)相應(yīng)的動作每個case語句里必須是一個IO操作，確切的說，應(yīng)該是一個面向channel的IO操作。

注：Go 語言的 select 語句借鑒自 Unix 的 select() 函數(shù)，在 Unix 中，可以通過調(diào)用 select() 函數(shù)來監(jiān)控一系列的文件句柄，一旦其中一個文件句柄發(fā)生了 IO 動作，該 select() 調(diào)用就會被返回（C 語言中就是這么做的），后來該機制也被用于實現(xiàn)高并發(fā)的 Socket 服務(wù)器程序。Go 語言直接在語言級別支持 select關(guān)鍵字，用于處理并發(fā)編程中通道之間異步 IO 通信問題。

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

知識點

• select語句只能用于信道的讀寫操作
• select中的case條件(非阻塞)是并發(fā)執(zhí)行的，select會選擇先操作成功的那個case條件去執(zhí)行，如果多個同時返回，則隨機選擇一個執(zhí)行，此時將無法保證執(zhí)行順序。對于阻塞的case語句會直到其中有信道可以操作，如果有多個信道可操作，會隨機選擇其中一個 case 執(zhí)行
• 對于case條件語句中，如果存在信道值為nil的讀寫操作，則該分支將被忽略，可以理解為從select語句中刪除了這個case語句
• 如果有超時條件語句，判斷邏輯為如果在這個時間段內(nèi)一直沒有滿足條件的case,則執(zhí)行這個超時case。如果此段時間內(nèi)出現(xiàn)了可操作的case,則直接執(zhí)行這個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語句是隨機執(zhí)行的

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")
? ? }
}

　　多次執(zhí)行的話，會隨機輸出不同的值，分別為1,2,write。這是因為ch和ch2是并發(fā)執(zhí)行會同時返回數(shù)據(jù)，所以會隨機選擇一個case執(zhí)行，。但永遠(yuǎn)不會執(zhí)行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通道，被優(yōu)化掉了。
要解決這個問題，只能使用make()進行初始化才可以?！　?/p>

4. 超時用法

package main
?
import (
? ? "fmt"
? ? "time"
)
?
func main() {
? ? ch := make(chan int)
? ? go func(c chan int) {
? ? ? ? // 修改時間后,再查看執(zhí)行結(jié)果
? ? ? ? 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監(jiān)聽各個case的IO事件，每個case都是阻塞的。上面的例子中，我們希望select在獲取到quit通道里面的數(shù)據(jù)時立即退出循環(huán)，但由于他在for{}里面，在第一次讀取quit后，僅僅退出了select{}，并未退出for，所以下次還會繼續(xù)執(zhí)行select{}邏輯，此時永遠(yuǎn)是執(zhí)行default，直到quit通道里讀到數(shù)據(jù)，否則會一直在一個死循環(huán)中運行，即使放到一個goroutine里運行，也是會占滿所有的CPU。

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

補充：7. 使用 select 切換協(xié)程

從不同的并發(fā)執(zhí)行的協(xié)程中獲取值可以通過關(guān)鍵字select來完成，它和switch控制語句非常相似也被稱作通信開關(guān)；它的行為像是“你準(zhǔn)備好了嗎”的輪詢機制；select監(jiān)聽進入通道的數(shù)據(jù)，也可以是用通道發(fā)送值的時候。

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

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

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

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

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

一秒內(nèi)的輸出非常驚人，如果我們給它計數(shù)（goroutine_select2.go），得到了 90000 個左右的數(shù)字。

到此這篇關(guān)于go select的用法的文章就介紹到這了,更多相關(guān)go select內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論