Golang 並發編程：選擇器（select）與超時處理

---

簡介

在 Go 語言中，Goroutine 讓我們可以輕鬆建立成千上萬的輕量級執行緒，而 channel 則提供了 Goroutine 之間安全的通訊機制。當一個程式同時監聽多個 channel 時，若僅使用 for { <-ch } 這樣的寫法會變得笨拙且易出錯。這時 select 就派上用場：它能同時等待多個 channel 的訊息，並在其中任一可用時立即執行對應的分支。

實務開發中，超時（timeout） 是不可或缺的需求——無論是呼叫外部 API、資料庫查詢，或是等待使用者輸入，都不應讓程式永遠卡在阻塞的 recv 或 send 上。結合 select 與 time.After，我們可以在指定時間內自動放棄等待，讓服務保持高可用性與良好使用者體驗。

本篇文章將從概念說明、實作範例、常見陷阱到最佳實踐，完整介紹 select 與超時處理的技巧，幫助初學者快速上手，同時提供中階開發者在大型系統中運用的參考。

---

核心概念

1. select 的基本語法

select 與 switch 類似，但它只能用於 channel 操作（接收或傳送）。語法如下：

select {
case v := <-ch1:        // 從 ch1 接收資料
    // 處理 v
case ch2 <- v2:        // 向 ch2 傳送資料
    // 傳送成功後的動作
default:               // 若所有 case 都無法立即執行，走這裡
    // 非阻塞的 fallback
}

• 隨機選擇：若同時有多個 case 可執行，select 會隨機挑選其中一個，避免長時間偏向同一條路徑。
• 阻塞行為：若沒有任何 case 可立即執行且沒有 default，select 會阻塞，直到至少有一個 case 可執行。

2. 超時的實作：time.After

time.After(d) 會回傳一個只會在 d 時間後收到訊號的 channel。將它放入 select，即可實現「等 X 秒，若仍未收到其他訊號就超時」的邏輯。

select {
case v := <-dataCh:
    fmt.Println("收到資料:", v)
case <-time.After(2 * time.Second):
    fmt.Println("等待超時")
}

3. 多路復用（Multiplexing）

在真實系統裡，我們常同時監聽 多個來源（例如多個 worker、訊息佇列、或是系統訊號）。select 能把這些來源「合併」成一條執行路徑，程式碼保持簡潔且易於維護。

for {
    select {
    case msg := <-msgCh:
        handleMessage(msg)
    case err := <-errCh:
        log.Println("錯誤:", err)
    case <-ctx.Done(): // 透過 context 取消
        fmt.Println("程式結束")
        return
    }
}

4. default 的用途

default 讓 select 成為 非阻塞 的檢查點。常用於：

• 輪詢：在不想阻塞主執行緒的情況下，定期檢查是否有新訊息。
• 避免死鎖：在寫入滿載 channel 前先檢查，若無法寫入則採取備援策略。

select {
case ch <- data:
    fmt.Println("資料已寫入")
default:
    fmt.Println("緩衝區已滿，跳過寫入")
}

5. 結合 context 進行可取消的等待

context.Context 本身就提供了一個 Done() channel，配合 select 可以同時支援 超時、手動取消 與 其他訊號。

ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()

select {
case v := <-workCh:
    fmt.Println("工作完成:", v)
case <-ctx.Done():
    fmt.Println("工作被取消或超時:", ctx.Err())
}

---

程式碼範例

下面提供 五個 常見且實用的範例，從最簡單的 select 使用，到結合 context、sync.WaitGroup、以及錯誤處理的完整範例。

範例 1：基本的 select 與超時

package main

import (
    "fmt"
    "time"
)

func main() {
    dataCh := make(chan string)

    // 模擬 1 秒後送出資料
    go func() {
        time.Sleep(1 * time.Second)
        dataCh <- "hello"
    }()

    select {
    case msg := <-dataCh:
        fmt.Println("收到訊息:", msg)
    case <-time.After(500 * time.Millisecond):
        fmt.Println("超時！未收到資料")
    }
}

說明：time.After(500ms) 先於 dataCh 的訊息到達，因而走到超時分支。若把 After 時間調長，就會看到收到資料的結果。

---

範例 2：非阻塞寫入（使用 default）

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int, 2) // 緩衝區大小 2
    ch <- 1
    ch <- 2 // 目前已滿

    // 嘗試寫入第三筆資料，若無法立即寫入則跳過
    select {
    case ch <- 3:
        fmt.Println("寫入成功")
    default:
        fmt.Println("緩衝區已滿，寫入失敗")
    }
}

說明：因為緩衝區已滿，default 分支會被執行，避免程式卡住。

---

範例 3：同時監聽多個 channel

package main

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

func worker(id int, out chan<- string) {
    delay := time.Duration(rand.Intn(1500)) * time.Millisecond
    time.Sleep(delay)
    out <- fmt.Sprintf("worker %d 完成（%v）", id, delay)
}

func main() {
    rand.Seed(time.Now().UnixNano())
    ch1, ch2, ch3 := make(chan string), make(chan string), make(chan string)

    go worker(1, ch1)
    go worker(2, ch2)
    go worker(3, ch3)

    for i := 0; i < 3; i++ {
        select {
        case msg := <-ch1:
            fmt.Println(msg)
        case msg := <-ch2:
            fmt.Println(msg)
        case msg := <-ch3:
            fmt.Println(msg)
        }
    }
}

說明：select 會在三個 worker 任一完成時立即回傳結果，順序不一定，展示了 多路復用 的威力。

---

範例 4：結合 context 的可取消等待

package main

import (
    "context"
    "fmt"
    "time"
)

func longTask(ctx context.Context, result chan<- int) {
    // 假設任務需要 5 秒
    select {
    case <-time.After(5 * time.Second):
        result <- 42
    case <-ctx.Done():
        // 被取消時直接返回
        fmt.Println("任務被取消")
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    resCh := make(chan int)
    go longTask(ctx, resCh)

    select {
    case v := <-resCh:
        fmt.Println("任務完成，結果:", v)
    case <-ctx.Done():
        fmt.Println("超時或手動取消:", ctx.Err())
    }
}

說明：context.WithTimeout 會在 2 秒後自動關閉 Done()，longTask 內部同時監聽 ctx.Done()，因此能即時結束長時間任務，避免資源浪費。

---

範例 5：使用 sync.WaitGroup 與 select 處理多任務超時

package main

import (
    "fmt"
    "sync"
    "time"
)

func fetch(id int, wg *sync.WaitGroup, out chan<- string) {
    defer wg.Done()
    // 每個任務的執行時間不同
    time.Sleep(time.Duration(500+id*300) * time.Millisecond)
    out <- fmt.Sprintf("task-%d 完成", id)
}

func main() {
    var wg sync.WaitGroup
    resultCh := make(chan string, 3)

    // 啟動三個任務
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go fetch(i, &wg, resultCh)
    }

    // 另一個 goroutine 等待所有任務結束後關閉 channel
    go func() {
        wg.Wait()
        close(resultCh)
    }()

    timeout := time.After(1 * time.Second)

    for {
        select {
        case msg, ok := <-resultCh:
            if !ok {
                fmt.Println("所有任務已結束")
                return
            }
            fmt.Println(msg)
        case <-timeout:
            fmt.Println("總超時，尚有任務未完成")
            return
        }
    }
}

說明：select 同時監聽 resultCh（任務結果）與 timeout，若在 1 秒內未收到全部結果，就會提前結束。這種模式在 批次處理 或 API 聚合 時非常常見。

---

常見陷阱與最佳實踐

陷阱	為何會發生	解決方式
忘記 default 造成死鎖	select 只包含阻塞的 recv/send，而所有 channel 都暫時不可用時程式會永久等待。	若不想阻塞，加入 default 分支或使用 time.After 設置超時。
time.After 產生記憶體泄漏	每次呼叫 time.After 都會建立一個 timer，若頻繁呼叫且未被觸發，timer 仍會保留在記憶體中。	使用 time.NewTimer 並在不需要時呼叫 Stop()，或在長迴圈中重複使用同一個 timer。
在 select 中直接使用 close(ch)	若多個 goroutine 同時寫入同一 channel，關閉 channel 會導致 panic。	只在唯一的「生產者」或透過 sync.Once 確保只關閉一次。
忘記 break/return 造成無限迴圈	select 本身不會自動退出迴圈，若在 for 中使用而未在分支內跳出，會持續阻塞。	在需要結束時使用 return、break 或 goto，或將 select 包在 for 條件內。
使用未緩衝 channel 造成不必要的阻塞	當發送方與接收方不在同一時間執行時，未緩衝 channel 會讓發送方阻塞。	根據需求選擇適當的緩衝大小，或改用 select + default 做非阻塞寫入。

最佳實踐

1. 盡量使用 context：它提供了統一的取消、超時與傳遞訊號的方式，讓程式更具可測試性。
2. 避免在熱路徑頻繁建立 time.After：改用 time.NewTimer + Stop()，或在外層建立一次性 timer。
3. 為每個 channel 加上註解：說明它的用途、緩衝大小與誰負責關閉，提升可讀性。
4. 在 select 前先檢查 ctx.Err()：即使 select 包含 ctx.Done()，提前檢查可以避免不必要的阻塞。
5. 使用 default 進行「輪詢」：在需要定時執行其他工作（例如心跳）時，將 default 放在 select 之中，配合 time.Tick 使用。

---

實際應用場景

場景	為何需要 select + 超時	範例簡述
HTTP 客戶端呼叫外部服務	網路不穩定時可能無回應，需要在一定時間內放棄。	select 監聽 respCh 與 time.After(2 * time.Second)，超時則回傳錯誤。
資料庫連線池	取得連線的等待時間過長會影響整體效能。	使用 select 從 poolCh 取連線，若 time.After(poolTimeout) 先觸發則返回 ErrPoolTimeout。
即時訊息推送（WebSocket）	客戶端斷線或心跳失敗需要即時偵測。	select 同時監聽 msgCh、pingTicker.C、ctx.Done()，確保即時回應與自動關閉。
多任務聚合（Fan‑in）	同時向多個微服務發送請求，需在所有回應或超時前回傳結果。	為每個請求啟動 goroutine，使用 select + sync.WaitGroup + time.After 收集回應或提前結束。
背景工作排程	任務執行時間過長時需要自動中止，避免資源被長時間佔用。	在工作函式內部使用 select 監聽 ctx.Done()，外層使用 context.WithTimeout 設定上限。

---

總結

select 是 Go 並發程式設計的核心工具，讓我們能 同時監聽多條通道、實現非阻塞操作，以及 結合超時與取消機制。透過 time.After、time.NewTimer、以及 context，可以把 超時處理 輕鬆整合進任何 Goroutine 流程中。

在實務開發時，記得：

• 明確規劃 channel 的生命週期（誰負責關閉、緩衝大小為何）。
• 使用 context 統一管理取消與超時，避免散落的 time.After 造成資源浪費。
• 加入 default 或超時分支，防止意外的死鎖。
• 測試與觀察：在壓測或故障注入時檢查是否有意外的阻塞或資源泄漏。

掌握了 select 與超時的技巧，你將能寫出 高效、彈性且可靠 的 Go 並發程式，從簡單的 I/O 讀寫到大型微服務系統的協調，都能游刃有餘。祝你在 Golang 的並發世界裡玩得開心、寫得順手！