哈嘍大家好，我是陳明勇，本文介紹的內容是 Go select 語句。如果本文對你有幫助，不妨點個贊，如果你是 Go 語言初學者，不妨點個關注，一起成長一起進步，如果本文有錯誤的地方，歡迎指出！

前言

在 Go 語言中，Goroutine 和 Channel 是非常重要的併發編程概念，它們可以幫助我們解決併發編程中的各種問題。關於它們的基本概念和用法，前面的文章 一文初探 Goroutine 與 channel 中已經進行了介紹。而本文將重點介紹 select，它是協調多個 channel 的橋樑。

select 介紹

什麼是 select

select 是 Go 語言中的一種控制結構，用於在多個通信操作中選擇一個可執行的操作。它可以協調多個 channel 的讀寫操作，使得我們能夠在多個 channel 中進行非阻塞的數據傳輸、同步和控制。

爲什麼需要 select

Go 語言中的 select 語句是一種用於多路複用通道的機制，它允許在多個通道上等待並處理消息。相比於簡單地使用 for 循環遍歷通道，使用 select 語句能夠更加高效地管理多個通道。

以下是一些 select 語句的使用場景：

• 等待多個通道的消息（多路複用）

  當我們需要等待多個通道的消息時，使用 select 語句可以非常方便地等待這些通道中的任意一個通道有消息到達，從而避免了使用多個 goroutine 進行同步和等待。

• 超時等待通道消息

  當我們需要在一段時間內等待某個通道有消息到達時，使用 select 語句可以與 time 包結合使用實現定時等待。

• 在通道上進行非阻塞讀寫

  在使用通道進行讀寫時，如果通道沒有數據，讀操作或寫操作將會阻塞。但是使用 select 語句結合 default 分支可以實現非阻塞讀寫，從而避免了死鎖或死循環等問題。

因此，select 的主要作用是在處理多個通道時提供了一種高效且易於使用的機制，簡化了多個 goroutine 的同步和等待，使程序更加可讀、高效和可靠。

select 基礎

語法

select {
    case <- channel1:
        // channel1準備好了
    case data := <- channel2:
        // channel2準備好了，並且可以讀取到數據data
    case channel3 <- data:
        // channel3準備好了，並且可以往其中寫入數據data
    default:
        // 沒有任何channel準備好了
}

其中， <- channel1 表示讀取 channel1 的數據，data <- channel2 表示用 data 去接收數據；channel3 <- data 表示往 channel3 中寫入數據。

select 的語法形式類似於 switch，但是它只能用於 channel 操作。在 select 語句中，我們可以定義多個 case，每個 case 都是一個 channel 操作，用於讀取或寫入數據。如果有多個 case 同時可執行，則會隨機選擇其中一個。如果沒有任何可執行的 case，則會執行 default 分支（如果存在），或者阻塞等待直到至少有一個 case 可執行爲止。

基本用法

package main

import (
   "fmt"
   "time"
)

func main() {
   ch1 := make(chanint)
   ch2 := make(chanint)

   gofunc() {
      time.Sleep(1 * time.Second)
      ch1 <- 1
   }()

   gofunc() {
      time.Sleep(2 * time.Second)
      ch2 <- 2
   }()
   for i := 0; i < 2; i++ {
      select {
      case data, ok := <-ch1:
         if ok {
            fmt.Println("從 ch1 接收到數據:", data)
         } else {
            fmt.Println("通道已被關閉")
         }
      case data, ok := <-ch2:
         if ok {
            fmt.Println("從 ch2接收到數據: ", data)
         } else {
            fmt.Println("通道已被關閉")
         }
      }
   }

   select {
   case data, ok := <-ch1:
      if ok {
         fmt.Println("從 ch1 接收到數據:", data)
      } else {
         fmt.Println("通道已被關閉")
      }
   case data, ok := <-ch2:
      if ok {
         fmt.Println("從 ch2接收到數據: ", data)
      } else {
         fmt.Println("通道已被關閉")
      }
   default:
      fmt.Println("沒有接收到數據，走 default 分支")
   }
}

執行結果

從 ch1 接收到數據: 1
從 ch2接收到數據:  2
沒有接收到數據，走 default 分支

上述示例中，首先創建了兩個 channel，ch1 和 ch2，分別在不同的 goroutine 中向兩個 channel 中寫入數據。然後，在主 goroutine 中使用 select 語句監聽兩個channel，一旦某個 channel 上有數據流動，就打印出相應的數據。由於 ch1 中的數據比 ch2 中的數據先到達，因此首先會打印出 "從 ch1 接收到數據: 1"，然後纔打印出 "從 ch2接收到數據: 2"。

爲了方便測試 default 分支，我寫了兩個 select 代碼塊，執行到第二個 select 代碼塊的時候，由於 ch1 和 ch2 都沒有數據了，因此執行 default 分支，打印 "沒有接收到數據，走 default 分支"。

一些使用 select 與 channel 結合的場景

實現超時控制

package main

import (
   "fmt"
   "time"
)

func main() {
   ch := make(chanint)
   gofunc() {
      time.Sleep(3 * time.Second)
      ch <- 1
   }()

   select {
   case data, ok := <-ch:
      if ok {
         fmt.Println("接收到數據: ", data)
      } else {
         fmt.Println("通道已被關閉")
      }
   case <-time.After(2 * time.Second):
      fmt.Println("超時了！")
   }
}

執行結果爲：超時了！。

在這個例子中，程序將在 3 秒後向 ch 通道里寫入數據，而我在 select 代碼塊裏設置的超時時間爲 2 秒，如果在 2 秒內沒有接收到數據，則會觸發超時處理。

實現多任務併發控制

package main

import (
   "fmt"
)

func main() {
   ch := make(chanint)

   for i := 0; i < 10; i++ {
      gofunc(id int) {
         ch <- id
      }(i)
   }

   for i := 0; i < 10; i++ {
      select {
      case data, ok := <-ch:
         if ok {
            fmt.Println("任務完成：", data)
         } else {
            fmt.Println("通道已被關閉")
         }
      }
   }
}

執行結果（每次執行的順序都會不一致）：

任務完成：1
任務完成：5
任務完成：2
任務完成：3
任務完成：4
任務完成：0
任務完成：9
任務完成：6
任務完成：7
任務完成：8

在這個例子中，啓動了 10 個 goroutine 併發執行任務，並使用一個 channel 來接收任務的完成情況。在主函數中，使用 select 語句監聽這個 channel，每當接收到一個完成的任務時，就進行處理。

監聽多個通道的消息

package main

import (
   "fmt"
   "time"
)

func main() {
   ch1 := make(chanint)
   ch2 := make(chanint)

   // 開啓 goroutine 1 用於向通道 ch1 發送數據
   gofunc() {
      for i := 0; i < 5; i++ {
         ch1 <- i
         time.Sleep(time.Second)
      }
   }()

   // 開啓 goroutine 2 用於向通道 ch2 發送數據
   gofunc() {
      for i := 5; i < 10; i++ {
         ch2 <- i
         time.Sleep(time.Second)
      }
   }()

   // 主 goroutine 從 ch1 和 ch2 中接收數據並打印
   for i := 0; i < 10; i++ {
      select {
      case data := <-ch1:
         fmt.Println("Received from ch1:", data)
      case data := <-ch2:
         fmt.Println("Received from ch2:", data)
      }
   }

   fmt.Println("Done.")
}

執行結果（每次執行程序打印的順序都不一致）：

Received from ch2: 5
Received from ch1: 0
Received from ch1: 1
Received from ch2: 6
Received from ch1: 2
Received from ch2: 7
Received from ch1: 3
Received from ch2: 8
Received from ch1: 4
Received from ch2: 9
Done.

該示例代碼中，通過使用 select 多路複用，可以同時監聽多個通道的數據，並避免了使用多個 goroutine 進行同步和等待的問題。

使用 default 實現非阻塞讀寫

import (
   "fmt"
   "time"
)

func main() {
   ch := make(chanint, 1)

   gofunc() {
      for i := 1; i <= 5; i++ {
         ch <- i
         time.Sleep(1 * time.Second)
      }
      close(ch)
   }()

   for {
      select {
      case val, ok := <-ch:
         if ok {
            fmt.Println(val)
         } else {
            ch = nil
         }
      default:
         fmt.Println("No value ready")
         time.Sleep(500 * time.Millisecond)
      }
      if ch == nil {
         break
      }
   }
}

執行結果（每次執行程序打印的順序都不一致）：

No value ready
1
No value ready
2
No value ready
No value ready
3
No value ready
No value ready
4
No value ready
No value ready
5
No value ready
No value ready

這個代碼中，使用了 default 分支來實現非阻塞的通道讀取和寫入操作。在 select 語句中，如果有通道已經準備好進行讀寫操作，那麼就會執行相應的分支。但是如果沒有任何通道準備好讀寫，那麼就會執行 default 分支中的代碼。

select 的注意事項

以下是關於 select 語句的一些注意事項：

• select 語句只能用於通信操作，如 channel 的讀寫，不能用於普通的計算或函數調用。

• select 語句會阻塞，直到至少有一個 case 語句滿足條件。如果有多個 case 語句滿足條件，則會隨機選擇一個執行。

• 如果沒有 case 語句滿足條件，並且有 default 語句，則會執行 default 語句。

• 在 select 語句中使用 channel 時，必須保證 channel 是已經初始化的。

• 如果一個通道被關閉，那麼仍然可以從它中讀取數據，直到它被清空，此時會返回通道元素類型的零值和一個布爾值，指示通道是否已關閉。

總之，在使用 select 語句時，要仔細考慮每個 case 語句的條件和執行順序，避免死鎖和其他問題。

總結

本文主要介紹了 Go 語言中的 select 語句。在文章中，首先介紹了 select 的基本概念，包括它是一種用於在多個通道之間進行選擇的語句，以及爲什麼需要使用 select。

接下來，文章詳細介紹了 select 的基礎知識，包括語法和基礎用法。在語法方面，講解了 select 語句的基本結構以及如何使用 case 子句進行通道選擇。在基礎用法方面，介紹瞭如何使用 select 語句進行通道的讀取和寫入操作，並講解了一些注意事項。

在接下來的內容中，文章列舉了一些使用 select 與 channel 結合的場景。這些場景包括實現超時控制、實現多任務併發控制、監聽多個通道的消息以及使用 default 實現非阻塞讀寫。對於每個場景，文章都詳細介紹瞭如何使用 select 語句實現。

最後，文章總結了 select 的注意事項，包括選擇的通道必須是可讀或可寫的通道、select 語句中的 case 子句必須是通道操作或者空的 default 子句，不能是其他類型的語句等等。

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/pTw4-p_o_RXlym7qs0KYWA