select 關(guān)鍵字

我們可以使用select關(guān)鍵字來(lái)同時(shí)監(jiān)聽(tīng)多個(gè)goroutine。

package main

import (
    "fmt"
    "time"
)

func main() {
    c1 := make(chan string)
    c2 := make(chan string)

    go func() {
        time.Sleep(1 * time.Second)
        c1 <- time.Now().String()
    }()

    go func() {
        time.Sleep(2 * time.Second)
        c2 <- time.Now().String()
    }()

    for i := 0; i < 2; i++ {
        select {
        case res1 := <-c1:
            fmt.Println("from c1:", res1)
        case res2 := <-c2:
            fmt.Println("from c2:", res2)
        }
    }
}

from c1: 2022-09-04 14:30:39.4469184 -0400 EDT m=+1.000172801
from c2: 2022-09-04 14:30:40.4472699 -0400 EDT m=+2.000524401

上面的代碼顯示了select關(guān)鍵字是如何工作的：

• 我們首先創(chuàng)建兩個(gè) channel c1和c2來(lái)監(jiān)聽(tīng)。
• 然后我們生成兩個(gè)goroutine，分別向c1和c2發(fā)送當(dāng)前時(shí)間。
• 在for循環(huán)中，我們創(chuàng)建了一個(gè)select語(yǔ)句，并定義了兩個(gè) case：第一個(gè) case 是我們何時(shí)可以從c1接收，第二個(gè) case 是我們何時(shí)可以從c2接收。

你可以看到select語(yǔ)句和switch語(yǔ)句在設(shè)計(jì)上非常相似。兩者都定義了不同的情況，并在滿足某種情況時(shí)運(yùn)行相應(yīng)的代碼。另外，我們可以看到select語(yǔ)句是阻塞的。也就是說(shuō)，它將等待，直到其中一個(gè) case 被滿足。

我們?yōu)檫@個(gè)循環(huán)迭代了兩次，因?yàn)橹挥袃蓚€(gè)goroutine需要監(jiān)聽(tīng)。更確切地說(shuō)，每個(gè)goroutine都是一個(gè)fire-and-forget goroutine，意味著它們?cè)诜祷刂爸幌蛞粋€(gè)通道發(fā)送一次。因此，在這段代碼中，任何時(shí)候都有兩個(gè)消息的最大值，而我們只需要選擇兩次。

如果我們不知道工作何時(shí)會(huì)結(jié)束呢

有時(shí)我們不知道有多少個(gè)工作。在這種情況下，把 select 語(yǔ)句放在一個(gè)while循環(huán)里。

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    c1 := make(chan string)
    rand.Seed(time.Now().UnixNano())

    for i := 0; i < rand.Intn(10); i++ {
        go func() {
            time.Sleep(1 * time.Second)
            c1 <- time.Now().String()
        }()
    }

    for {
        select {
        case res1 := <-c1:
            fmt.Println("from c1:", res1)
        }
    }
}

因?yàn)槲覀冏屢粋€(gè)隨機(jī)數(shù)的goroutines運(yùn)行，所以我們不知道有多少個(gè)作業(yè)。值得慶幸的是，底部包裹著select語(yǔ)句的for循環(huán)將捕獲每一個(gè)輸出。讓我們看看如果我們運(yùn)行這段代碼會(huì)發(fā)生什么。

from c1: 2022-09-04 14:48:47.5145341 -0400 EDT m=+1.000257801
from c1: 2022-09-04 14:48:47.5146126 -0400 EDT m=+1.000336201
from c1: 2022-09-04 14:48:47.5146364 -0400 EDT m=+1.000359901
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
        /home/jacob/blog/testing/listening-to-multiple-channels-in-go/main.go:22 +0x128
exit status 2

嗯，select 語(yǔ)句按預(yù)期收到了三次，但由于死鎖，程序出錯(cuò)了。為什么會(huì)出現(xiàn)這種情況？

記住，在沒(méi)有任何條件的情況下，Go中的for循環(huán)會(huì)永遠(yuǎn)運(yùn)行。這意味著 select 語(yǔ)句將永遠(yuǎn)嘗試接收。然而，要運(yùn)行的作業(yè)數(shù)量是有限的。即使沒(méi)有更多的工作，select 語(yǔ)句仍然會(huì)嘗試接收。

還記得在本系列的第一篇文章中我說(shuō)過(guò)，如果你在發(fā)送方?jīng)]有準(zhǔn)備好的時(shí)候試圖從一個(gè)沒(méi)有緩沖的通道中接收，你的程序就會(huì)陷入死鎖。這正是我們例子中的情況。

那么我們?nèi)绾谓鉀Q這個(gè)問(wèn)題呢？我們可以使用以前文章中涉及的概念的組合：退出通道和WaitGroups。

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

func main() {
    c1 := make(chan string)
    exit := make(chan struct{})
    rand.Seed(time.Now().UnixNano())
    var wg sync.WaitGroup

    go func() {
        numJob := rand.Intn(10)
        fmt.Println("number of jobs:", numJob)
        for i := 0; i < numJob; i++ {
            wg.Add(1)
            go func() {
                defer wg.Done()
                time.Sleep(1 * time.Second)
                c1 <- time.Now().String()
            }()
        }
        wg.Wait()
        close(exit)
    }()

    for {
        select {
        case res1 := <-c1:
            fmt.Println("from c1:", res1)
        case <-exit:
            return
        }
    }
}

3
from c1: 2022-09-04 15:09:08.6936976 -0400 EDT m=+1.000287801
from c1: 2022-09-04 15:09:08.6937788 -0400 EDT m=+1.000369101
from c1: 2022-09-04 15:09:08.6937949 -0400 EDT m=+1.000385101

• 我們創(chuàng)建一個(gè) exit channel 和一個(gè)WaitGroup。
• 每次運(yùn)行的作業(yè)數(shù)都是隨機(jī)的。對(duì)于numJobs的次數(shù)，我們啟動(dòng)goroutines。為了等待作業(yè)的完成，我們把它們加到wg中。當(dāng)一個(gè)工作完成后，我們從wg中減去一個(gè)。
• 一旦所有工作完成，我們就關(guān)閉exit channel。
• 我們將上述部分包裹在一個(gè)goroutine中，因?yàn)槲覀兿Ｍ械牟糠侄际菬o(wú)阻塞的。如果我們不把它包在一個(gè)goroutine中，wg.Wait()就會(huì)等待，直到作業(yè)完成。這將阻塞代碼，并且不會(huì)讓底部的for-select語(yǔ)句運(yùn)行。
• 此外，由于c1是一個(gè)未緩沖的通道，等待所有的goroutine將消息發(fā)送到c1，將導(dǎo)致許多消息被發(fā)送到c1而沒(méi)有for-select語(yǔ)句接收。這就導(dǎo)致了一個(gè)死鎖，因?yàn)楫?dāng)發(fā)送者準(zhǔn)備好時(shí)，接收者還沒(méi)有準(zhǔn)備好。

如何使select成為非阻塞式的

select語(yǔ)句默認(rèn)是阻塞的。我們?nèi)绾问蛊涑蔀榉亲枞哪?？這很簡(jiǎn)單--我們只需添加一個(gè) default case。

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

func main() {
    ashleyMsg := make(chan string)
    brianMsg := make(chan string)
    exit := make(chan struct{})
    rand.Seed(time.Now().UnixNano())
    var wg sync.WaitGroup

    go func() {
        numJob := rand.Intn(10)
        fmt.Println("number of jobs:", numJob)
        for i := 0; i < numJob; i++ {
            wg.Add(2)
            go func() {
                defer wg.Done()
                time.Sleep(time.Duration(rand.Intn(10)) * time.Millisecond)
                ashleyMsg <- "hi"
            }()
            go func() {
                defer wg.Done()
                time.Sleep(time.Duration(rand.Intn(10)) * time.Millisecond)
                brianMsg <- "what's up"
            }()
        }
        wg.Wait()
        close(exit)
    }()

    for {
        select {
        case res1 := <-ashleyMsg:
            fmt.Println("ashley:", res1)
        case res2 := <-brianMsg:
            fmt.Println("brian:", res2)
        case <-exit:
            fmt.Println("chat ended")
            return
        default:
            fmt.Println("...")
            time.Sleep(time.Millisecond)
        }
    }
}

...
number of jobs: 4
brian: what's up
...
ashley: hi
...
...
brian: what's up
ashley: hi
ashley: hi
brian: what's up
...
...
ashley: hi
...
brian: what's up
...
chat ended

除了蹩腳的對(duì)話之外，我們可以看到默認(rèn)情況下的工作方式。與其等待聊天記錄的到來(lái)，我們可以在沒(méi)有頻道可以接收的時(shí)候做一些事情。在這個(gè)例子中，我們只是打印出省略號(hào)，但你可以做任何你想做的事情。

到此這篇關(guān)于詳解如何在Golang中監(jiān)聽(tīng)多個(gè)channel的文章就介紹到這了,更多相關(guān)Golang監(jiān)聽(tīng)多個(gè)channel內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論