詳解如何在Golang中監聽多個channel

2023-03-17 06:04:54

select 關鍵字

我們可以使用select關鍵字來同時監聽多個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關鍵字是如何工作的：

我們首先建立兩個 channel c1和c2來監聽。
然後我們生成兩個goroutine，分別向c1和c2傳送當前時間。
在for迴圈中，我們建立了一個select語句，並定義了兩個 case：第一個 case 是我們何時可以從c1接收，第二個 case 是我們何時可以從c2接收。

你可以看到select語句和switch語句在設計上非常相似。兩者都定義了不同的情況，並在滿足某種情況時執行相應的程式碼。另外，我們可以看到select語句是阻塞的。也就是說，它將等待，直到其中一個 case 被滿足。

我們為這個迴圈迭代了兩次，因為只有兩個goroutine需要監聽。更確切地說，每個goroutine都是一個fire-and-forget goroutine，意味著它們在返回之前只向一個通道傳送一次。因此，在這段程式碼中，任何時候都有兩個訊息的最大值，而我們只需要選擇兩次。

如果我們不知道工作何時會結束呢

有時我們不知道有多少個工作。在這種情況下，把 select 語句放在一個while迴圈裡。

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

因為我們讓一個亂數的goroutines執行，所以我們不知道有多少個作業。值得慶幸的是，底部包裹著select語句的for迴圈將捕獲每一個輸出。讓我們看看如果我們執行這段程式碼會發生什麼。

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 語句按預期收到了三次，但由於死鎖，程式出錯了。為什麼會出現這種情況？

記住，在沒有任何條件的情況下，Go中的for迴圈會永遠執行。這意味著 select 語句將永遠嘗試接收。然而，要執行的作業數量是有限的。即使沒有更多的工作，select 語句仍然會嘗試接收。

還記得在本系列的第一篇文章中我說過，如果你在傳送方沒有準備好的時候試圖從一個沒有緩衝的通道中接收，你的程式就會陷入死鎖。這正是我們例子中的情況。

那麼我們如何解決這個問題呢？我們可以使用以前文章中涉及的概念的組合：退出通道和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

我們建立一個 exit channel 和一個WaitGroup。
每次執行的作業數都是隨機的。對於numJobs的次數，我們啟動goroutines。為了等待作業的完成，我們把它們加到wg中。當一個工作完成後，我們從wg中減去一個。
一旦所有工作完成，我們就關閉exit channel。
我們將上述部分包裹在一個goroutine中，因為我們希望所有的部分都是無阻塞的。如果我們不把它包在一個goroutine中，wg.Wait()就會等待，直到作業完成。這將阻塞程式碼，並且不會讓底部的for-select語句執行。
此外，由於c1是一個未緩衝的通道，等待所有的goroutine將訊息傳送到c1，將導致許多訊息被傳送到c1而沒有for-select語句接收。這就導致了一個死鎖，因為當傳送者準備好時，接收者還沒有準備好。

如何使select成為非阻塞式的

select語句預設是阻塞的。我們如何使其成為非阻塞的呢？這很簡單--我們只需新增一個 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

除了蹩腳的對話之外，我們可以看到預設情況下的工作方式。與其等待聊天記錄的到來，我們可以在沒有頻道可以接收的時候做一些事情。在這個例子中，我們只是列印出省略號，但你可以做任何你想做的事情。

到此這篇關於詳解如何在Golang中監聽多個channel的文章就介紹到這了,更多相關Golang監聽多個channel內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！

詳解如何在Golang中監聽多個channel

目錄

select 關鍵字

如果我們不知道工作何時會結束呢

如何使select成為非阻塞式的

熱門文章