This resume is also available in English.

一、Go 地基第 3 / 4 篇 · 全部目錄

專欄 › 一、Go 地基 › 第 3 篇

Goroutine、Channel 與並發模式

Goroutines, Channels and Concurrency Patterns in Go

從啟動一個 goroutine 開始,依序講 WaitGroup、資料競爭與 Mutex、channel 的語意、select、worker pool 與 pipeline,最後處理限制並發數、收集錯誤與 goroutine 洩漏,建立寫並發程式的基本功。

  • Go
  • Concurrency
  • Goroutine
  • Channel
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:啟動 goroutine,並等它結束
  3. 第 2 步:共享記憶體、資料競爭與 Mutex
  4. 第 3 步:channel:在 goroutine 之間傳遞資料
  5. 第 4 步:select:同時等待多件事
  6. 第 5 步:worker pool 與 pipeline
  7. 第 6 步:限制並發數並收集錯誤
  8. 第 7 步:避免 goroutine 洩漏
  9. 常見陷阱
  10. 重點整理
  11. 下一篇

上一篇〈錯誤處理:包裝、哨兵、自訂型別〉我們替訂單服務建立了一致的錯誤處理:在每一層包上上下文、用哨兵與自訂型別判斷、在邊界統一翻譯。不過那時所有程式都是一步接一步執行的;這篇接著讓訂單服務「同時做好幾件事」,並把並發中產生的結果與錯誤安全地收回來。

這篇要解決什麼

一個訂單服務在建立訂單時,常常需要查好幾樣東西:每個品項的價格、庫存是否足夠、使用者的優惠資格。如果這些查詢一個接一個做,總耗時就是每個查詢時間的總和;如果它們彼此獨立,同時發出去,總耗時就接近其中最慢的那一個。伺服器本身也一樣:每個進來的 HTTP 請求都在自己的 goroutine 裡處理,成千上萬個請求同時進行。

Go 把並發做成語言的一部分:用 go 關鍵字啟動 goroutine,用 channel 在 goroutine 之間傳遞資料,用 select 同時等待多件事。語法很少,但要寫對並不簡單。常見的問題包括:

  • 啟動了 goroutine,卻沒有等它結束,程式就先退出了。
  • 多個 goroutine 同時讀寫同一個變數,結果時好時壞(資料競爭)。
  • channel 沒人接收,傳送的 goroutine 永遠卡住,慢慢累積成記憶體洩漏。
  • 並發數沒有上限,一次打出幾萬個下游請求,把對方或自己的連線池打爆。
  • 其中一個 goroutine 失敗了,錯誤卻沒有傳回來,或其他 goroutine 還在白做工。

這篇會一步一步建立處理這些問題的工具,最後得到幾個可以直接套用的模式:fan-out 加 WaitGroup、worker pool、pipeline、限制並發數並收集錯誤。

第 1 步:啟動 goroutine,並等它結束

goroutine 是由 Go 執行環境排程的輕量執行緒。它的初始堆疊只有幾 KB,會依需要成長,建立與切換的成本遠低於作業系統執行緒,因此同時存在數萬個 goroutine 是很正常的事。Go 的排程器會把這些 goroutine 分配到數量約等於 CPU 核心數(GOMAXPROCS)的作業系統執行緒上執行,遇到阻塞的系統呼叫或網路 I/O 時會自動切換,讓其他 goroutine 繼續跑。

啟動 goroutine 只要在函式呼叫前加上 go。但 go 本身不會等待,main 函式一結束,整個程式就結束,不管還有多少 goroutine 沒跑完。所以每啟動一個 goroutine,都要先想好:誰負責等它結束?

最常用的工具是 sync.WaitGroup。Go 1.25 起,WaitGroup 多了 Go 方法,把「計數加一、啟動 goroutine、結束時計數減一」包成一個呼叫,避免忘了 Add 或把 Done 放錯位置:

package main

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

type Item struct {
	SKU string
	Qty int
}

// fetchPrice 模擬呼叫價格服務;每次耗時不同。
func fetchPrice(sku string) int64 {
	time.Sleep(time.Duration(50+rand.IntN(100)) * time.Millisecond)
	return int64(1000 + len(sku)*100) // 單位:分
}

func main() {
	items := []Item{{"book", 2}, {"pen", 10}, {"lamp", 1}}
	prices := make([]int64, len(items)) // 每個 goroutine 只寫自己的索引,不會互相干擾

	start := time.Now()
	var wg sync.WaitGroup
	for i, it := range items { // Go 1.22 起每次迭代都是新的 i 與 it,可以安心在閉包中使用
		wg.Go(func() {
			prices[i] = fetchPrice(it.SKU)
		})
	}
	wg.Wait() // 等所有查價結束

	var total int64
	for i, it := range items {
		total += prices[i] * int64(it.Qty)
	}
	fmt.Printf("total=%d 分,耗時約 %v(接近最慢的一次查詢,而非三次總和)\n",
		total, time.Since(start).Round(10*time.Millisecond))
}

這段程式有三個值得注意的地方:

  1. 每個 goroutine 寫入不同的切片元素。不同的切片索引是不同的記憶體位置,同時寫入不會互相衝突,所以不需要鎖。這是最簡單也最安全的收集結果方式。
  2. 迴圈變數可以直接在閉包中使用。Go 1.22 以前,for 迴圈的變數在整個迴圈中只有一份,閉包抓到的會是最後一次的值,所以舊程式碼常見 i := i 這種寫法。在 go.mod 宣告 1.22 以上之後,每次迭代都是新變數,這個陷阱消失了(這也是〈工程結構與 Go Modules〉提到 go 指令行會改變語意的例子)。
  3. wg.Wait() 一定在所有 wg.Go 之後。如果你用舊式的 wg.Add(1) 加 defer wg.Done(),Add 必須在啟動 goroutine 之前呼叫,而不是在 goroutine 內部,否則 Wait 可能在 Add 之前就返回。
依序執行:總時間 = 三段相加 book 查價 pen lamp 查價 main 並發執行:總時間 ≈ 最慢的一段 goroutine 1 book goroutine 2 pen goroutine 3 lamp main wg.Wait() wg.Go ×3 全部結束 時間

圖:依序執行的總時間是三段相加;並發執行時,主 goroutine 只需等到最慢的那個結束。

第 2 步:共享記憶體、資料競爭與 Mutex

上一步刻意讓每個 goroutine 寫不同位置。如果改成大家都累加到同一個 total 變數呢?total += x 實際上是「讀出、相加、寫回」三個動作,兩個 goroutine 交錯執行時,其中一個的結果可能被另一個覆蓋。這種「多個 goroutine 同時存取同一記憶體,且至少一個是寫入,又沒有同步」的狀況叫資料競爭(data race)。它的可怕之處在於大部分時候結果看起來是對的,只在高負載或特定時序下才出錯,而且 Go 的記憶體模型規定有資料競爭的程式行為是未定義的,不只是「數字算錯」而已,連讀到半寫完的字串、map 內部結構損毀都有可能。

Go 內建了競爭偵測器,測試與執行時加上 -race 就會在發生競爭時印出兩邊的堆疊:

go test -race ./...
go run -race ./cmd/order

它有執行期成本(記憶體與 CPU 都會增加數倍),所以通常用在 CI 的測試階段,而不是正式環境。偵測器只能找到「實際執行到」的競爭,所以測試覆蓋到並發路徑很重要,這部分在〈測試:表格驅動、httptest、整合測試〉會再談。

修正資料競爭有幾種工具:

工具適合情境注意
sync.Mutex保護一組相關的狀態(例如 map 加上計數)鎖住的範圍要小,不要在持有鎖時做 I/O
sync.RWMutex讀遠多於寫,且讀取的臨界區不算短臨界區很短時不一定比 Mutex 快,要量測
sync/atomic 型別單一計數器、旗標(atomic.Int64、atomic.Bool)只保證單一變數的原子性,多個變數之間的一致性不保證
sync.Once / sync.OnceValue只做一次的初始化初始化失敗也不會重試
channel把資料的擁有權交給另一個 goroutine下一步詳談

使用 Mutex 的慣例是把鎖和它保護的資料放在同一個結構裡,並在方法中加鎖,不讓呼叫端自己處理:

// 片段:用 Mutex 保護的庫存快取
type stockCache struct {
	mu    sync.Mutex
	stock map[string]int // 受 mu 保護
}

func (c *stockCache) Reserve(sku string, qty int) bool {
	c.mu.Lock()
	defer c.mu.Unlock()
	if c.stock[sku] < qty {
		return false
	}
	c.stock[sku] -= qty // 「檢查」與「扣減」在同一把鎖內,中間不會被插隊
	return true
}

注意「檢查」與「扣減」必須在同一次加鎖內完成。如果先加鎖讀出庫存、解鎖,再加鎖扣減,兩個 goroutine 可能都通過檢查,造成超賣。這類「先檢查後動作」的問題,在跨服務、跨資料庫時會變得更棘手,〈併發常見問題:從資料競爭到超賣〉會專門討論。

提示:sync.Mutex 不能被複製。把含有 Mutex 的結構以值傳遞,會得到一把獨立的新鎖,保護就失效了。go vet 的 copylocks 檢查會抓出這類錯誤,所以這種結構的方法一律用指標接收者。

第 3 步:channel:在 goroutine 之間傳遞資料

Go 的格言是「不要透過共享記憶體來溝通,而要透過溝通來共享記憶體」。channel 就是溝通的管道:一個 goroutine 把值送進去,另一個取出來,值的「擁有權」隨之轉移,同一時間只有一個 goroutine 在處理它,自然沒有競爭。

無緩衝與有緩衝

make(chan T) 建立無緩衝 channel:傳送者會一直阻塞,直到有接收者把值取走,雙方在這一刻「會合」。它同時傳遞了資料與同步訊號:傳送完成時,你知道對方已經收到。

make(chan T, n) 建立有緩衝 channel:緩衝區還有空位時,傳送立即返回;滿了才阻塞。接收則在緩衝區空時阻塞。緩衝區讓傳送端與接收端可以有短暫的速度差,但它不會讓慢的消費者變快,只是延後阻塞的時間點。選擇緩衝大小時,要能說出這個數字的理由(例如「等於 worker 數量」、「允許一批最多 100 筆」),而不是隨手填一個大數字掩蓋設計問題。

無緩衝 make(chan T):雙方會合 傳送者 ch <- v 同一時刻交手;沒有接收者就阻塞 接收者 <-ch 有緩衝 make(chan T, 3):滿了才阻塞 傳送者 v1 v2 v3 接收者 緩衝區(容量 3)已滿 送 v4 時阻塞 緩衝只吸收短暫的速度差,無法讓慢的接收者變快

圖:上方的無緩衝 channel,傳送與接收必須同時發生;下方容量 3 的 channel,前三次傳送直接放進緩衝區,第四次才阻塞。

關閉與 range

傳送端用 close(ch) 表示「不會再有值了」。接收端可以用 v, ok := <-ch 判斷:ok 為 false 代表 channel 已關閉且緩衝區已空;或直接用 for v := range ch,它會在 channel 關閉且取完後自動結束。關閉的規則只有一條要記住:由傳送端關閉,而且只關一次。接收端關閉 channel,會讓還在傳送的 goroutine panic。

channel 各狀態下的操作

這張表值得背起來,大部分 channel 相關的 bug 都來自這裡:

操作nil channel開啟中已關閉
傳送 ch <- v永遠阻塞有空位或接收者時成功,否則阻塞panic
接收 <-ch永遠阻塞有值時取得,否則阻塞立即返回零值,ok == false
關閉 close(ch)panic成功panic

「nil channel 永遠阻塞」看起來沒用,其實在 select 中很好用:把某個 case 的 channel 設成 nil,就等於暫時停用那個 case。

第 4 步:select:同時等待多件事

select 讓一個 goroutine 同時等待多個 channel 操作,哪個先就緒就執行哪個;同時有多個就緒時隨機挑一個,避免某個 case 永遠被餓死。三種最常見的用法:

// 片段:select 的三種常見用法

// 1. 逾時:最多等 2 秒
select {
case res := <-results:
	fmt.Println("got", res)
case <-time.After(2 * time.Second):
	fmt.Println("timeout")
}

// 2. 非阻塞傳送:佇列滿了就丟棄並記錄,而不是卡住請求
select {
case events <- ev:
default:
	dropped.Add(1)
}

// 3. 可被停止的迴圈:done 被關閉時結束
for {
	select {
	case <-done:
		return
	case job := <-jobs:
		handle(job)
	}
}

第三種用法裡的 done 是一個只用來「廣播停止」的 channel:關閉它時,所有正在等待 <-done 的 goroutine 都會同時被喚醒(因為從已關閉的 channel 接收會立即返回)。這是 Go 傳統上通知多個 goroutine 停止的方式,而下一篇的 context 正是把這個模式標準化,再加上逾時與原因。實務上,新的程式碼應該用 ctx.Done() 取代自製的 done channel。

提示:在迴圈中反覆呼叫 time.After 會一直建立新的計時器。Go 1.23 起未觸發的計時器可以被及時回收,不再像舊版那樣累積到觸發才釋放,但在熱路徑上仍建議重用一個 time.Timer 並在每輪 Reset,語意更清楚。

第 5 步:worker pool 與 pipeline

把前面的工具組合起來,就能得到幾個經典的並發模式。

worker pool:固定數量的 goroutine 消化工作

當工作數量很多(例如要對一萬筆訂單重新計算金額),為每筆工作開一個 goroutine 雖然可行,但會同時打出一萬個資料庫查詢。worker pool 固定開 N 個 goroutine,從同一個 jobs channel 取工作,處理完把結果送到 results channel。N 就是並發上限,通常依下游能承受的量(資料庫連線池大小、對方的速率限制)來決定。

生產者 送完 close(jobs) jobs worker 1 worker 2 worker 3 results 收集 wg.Wait() 後 close(results) worker 數量 = 並發上限,依下游能承受的量決定

圖:jobs 由生產者關閉;所有 worker 結束後再關閉 results,讓收集端的 range 能正常結束。

下面是完整的 worker pool。重點在「誰關閉哪個 channel」:jobs 由唯一的傳送者(生產者)在送完後關閉;results 有多個傳送者(所有 worker),所以不能由任何一個 worker 關閉,而是另開一個 goroutine 等所有 worker 結束後再關閉。

package main

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

type Order struct {
	ID     string
	UserID string
	Total  int64 // 單位:分
	Status string
}

type result struct {
	OrderID string
	Total   int64
	Err     error
}

// recalc 模擬重新計算一筆訂單的金額。
func recalc(o Order) (int64, error) {
	time.Sleep(20 * time.Millisecond)
	if o.Status == "cancelled" {
		return 0, fmt.Errorf("recalc %s: order is cancelled", o.ID)
	}
	return o.Total * 105 / 100, nil
}

func main() {
	orders := make([]Order, 12)
	for i := range 12 { // Go 1.22 起可以直接 range 一個整數
		orders[i] = Order{ID: fmt.Sprintf("o-%02d", i), UserID: "u-1", Total: int64(1000 * (i + 1)), Status: "pending"}
	}
	orders[5].Status = "cancelled"

	const workers = 3
	jobs := make(chan Order)
	results := make(chan result)

	// 生產者:唯一的傳送者,送完就關閉 jobs。
	go func() {
		defer close(jobs)
		for _, o := range orders {
			jobs <- o
		}
	}()

	// N 個 worker:從 jobs 取工作,直到 jobs 關閉。
	var wg sync.WaitGroup
	for range workers {
		wg.Go(func() {
			for o := range jobs {
				total, err := recalc(o)
				results <- result{OrderID: o.ID, Total: total, Err: err}
			}
		})
	}

	// results 有多個傳送者:等全部 worker 結束後再關閉。
	go func() {
		wg.Wait()
		close(results)
	}()

	// 收集端:range 會在 results 關閉後結束。
	var ok, failed int
	for r := range results {
		if r.Err != nil {
			failed++
			fmt.Println("error:", r.Err)
			continue
		}
		ok++
	}
	fmt.Printf("done: %d ok, %d failed\n", ok, failed)
}

結果的順序與輸入不同,這是並發處理的正常現象。如果需要保持順序,可以像第 1 步那樣用索引寫入預先配置好的切片,或在結果中帶上原始索引再排序。

pipeline:一串以 channel 相連的階段

pipeline 把處理拆成多個階段,每個階段是一組 goroutine,從上游 channel 讀、處理後寫到下游 channel。例如「讀取訂單 → 計算金額 → 寫回資料庫」。好處是每個階段可以有不同的並發度(計算是 CPU 密集,開少一點;寫回是 I/O 密集,開多一點),而且資料像水流一樣通過,不必等上一階段全部完成。

pipeline 的每個階段都遵守同樣的規則:階段擁有自己的輸出 channel,輸入讀完後就關閉輸出。這樣上游關閉會一路傳遞到下游,最終收集端的 range 自然結束。在某個階段內開多個 goroutine 讀同一個輸入叫 fan-out;把多個 channel 合併成一個叫 fan-in,做法就和上面 results 的關閉方式一樣:每個來源一個 goroutine 轉送,用 WaitGroup 等全部結束再關閉合併後的 channel。

第 6 步:限制並發數並收集錯誤

worker pool 適合「一大批同質工作」。另一種更常見的情境是:在處理一個請求時,要並發呼叫幾個到幾十個下游,限制同時進行的數量,而且任何一個失敗就要知道。

用有緩衝 channel 當號誌

有緩衝 channel 的容量可以當成號誌(semaphore):進入前送一個值佔位,緩衝區滿了就阻塞,結束時取出一個值釋放。它比 worker pool 更輕:不必預先開好 goroutine,每個工作仍然是自己的 goroutine,只是同時進入臨界區的最多 N 個。

收集所有錯誤

錯誤的收集可以結合上一篇的 errors.Join:每個 goroutine 把錯誤寫進自己的切片位置,全部結束後一次合併。

package main

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

// reserveStock 模擬呼叫庫存服務保留一個品項。
func reserveStock(sku string) error {
	time.Sleep(30 * time.Millisecond)
	if sku == "sold-out" {
		return fmt.Errorf("reserve %s: insufficient stock", sku)
	}
	return nil
}

// reserveAll 最多同時進行 limit 個保留,並回傳所有失敗。
func reserveAll(skus []string, limit int) error {
	sem := make(chan struct{}, limit) // 容量即並發上限
	errs := make([]error, len(skus))  // 各自寫自己的位置,不需要鎖

	var wg sync.WaitGroup
	for i, sku := range skus {
		wg.Go(func() {
			sem <- struct{}{}        // 佔位;滿了就等
			defer func() { <-sem }() // 釋放
			errs[i] = reserveStock(sku)
		})
	}
	wg.Wait()
	return errors.Join(errs...) // 全部成功時為 nil
}

func main() {
	skus := []string{"book", "pen", "sold-out", "lamp", "mug"}
	start := time.Now()
	err := reserveAll(skus, 2)
	fmt.Printf("耗時約 %v\n", time.Since(start).Round(10*time.Millisecond))
	if err != nil {
		fmt.Println("部分失敗:", err)
	}
}

這個版本會等所有工作完成,即使其中一個早就失敗了。如果你希望「第一個錯誤發生時就通知其他工作停止」,就需要一個能跨 goroutine 廣播的取消訊號,這正是下一篇 context 的主題。官方擴充套件 golang.org/x/sync/errgroup 把「WaitGroup + 第一個錯誤 + 取消 + 並發上限(SetLimit)」包成一個型別,是實務上最常用的寫法;理解了這一步的手工版本,就能清楚知道它在幫你做什麼。

該選哪一種模式

情境建議模式
固定幾個獨立查詢,結果要合併WaitGroup.Go + 依索引寫入切片
大量同質工作,需要固定並發度worker pool
多階段處理,各階段速度不同pipeline(fan-out / fan-in)
請求內並發呼叫下游,需要上限與錯誤號誌 + errors.Join,或 errgroup 搭配 SetLimit
共享的計數器或快取atomic 或 Mutex,而不是 channel

第 7 步:避免 goroutine 洩漏

goroutine 很便宜,但不是免費的:每一個都佔用堆疊,而且它引用的所有物件都無法被垃圾回收。一個永遠阻塞的 goroutine 就是一個洩漏。在每個請求都洩漏一個的情況下,服務會在幾小時或幾天後記憶體耗盡,而且很難從單一請求看出問題。

最典型的洩漏長這樣:啟動一個 goroutine 去查詢,用無緩衝 channel 回傳結果,呼叫端用 select 等結果或逾時。逾時發生時呼叫端走了,沒有人再接收,查詢的 goroutine 完成後卡在 ch <- res 上,永遠不會結束。修正方式有兩種:把 channel 改成容量 1,讓傳送者無論如何都能送出後結束;或讓查詢本身能被取消(下一篇)。

預防洩漏的原則:

  1. 每個 goroutine 都要有明確的結束條件:輸入 channel 被關閉、收到取消訊號,或工作完成。啟動 goroutine 時就要能回答「它什麼時候結束」。
  2. 傳送端要考慮接收端可能已經離開。用容量足夠的緩衝區,或在 select 中同時監聽取消訊號。
  3. 服務關閉時要等背景 goroutine 結束,而不是直接退出,否則正在處理的工作會被中斷。這在〈設定與優雅關閉〉會完整實作。

檢查方面,可以在測試結束時比對 runtime.NumGoroutine() 的數量;線上服務則透過 net/http/pprof 的 goroutine profile 查看目前所有 goroutine 卡在哪一行(〈效能調校:pprof 與 benchmark〉會介紹)。Go 1.25 起標準函式庫的 testing/synctest 提供了「虛擬時間」的測試泡泡,可以在不真的等待的情況下測試含有逾時與計時器的並發程式,並在泡泡結束時偵測仍然阻塞的 goroutine。

常見陷阱

  • 忘記等待 goroutine:main 或處理器先返回,goroutine 的工作被中斷或結果遺失。每個 go 都要配一個等待機制。
  • 在 goroutine 內呼叫 wg.Add:Wait 可能在 Add 之前返回。用 wg.Go,或在啟動前呼叫 Add。
  • 用 -race 以外的方式「確認沒有競爭」:跑一百次結果都對不代表沒有資料競爭。CI 一律加上 -race。
  • 對 map 並發讀寫:內建 map 不是並發安全的,執行期偵測到會直接以 fatal error 結束程式,且無法 recover。用 Mutex 保護,或在特定讀多寫少情境下用 sync.Map。
  • 由接收端關閉 channel,或關閉兩次:都會 panic。只由唯一的傳送者關閉;多個傳送者時,用 WaitGroup 等全部結束後再由一個 goroutine 關閉。
  • 傳送端在接收端離開後永遠阻塞:典型的 goroutine 洩漏。用容量 1 的緩衝區或取消訊號。
  • 無上限地開 goroutine 打下游:會耗盡連線池或觸發對方限流。用 worker pool 或號誌限制並發數。
  • 持有鎖時做 I/O:其他 goroutine 全部排隊等一個網路呼叫。鎖只保護記憶體中的狀態,I/O 移到鎖外。
  • 以為 channel 一定比 Mutex 好:單純的計數器或快取用 Mutex 或 atomic 更簡單也更快;channel 適合傳遞擁有權與協調流程。

重點整理

  • goroutine 很輕量,但每次 go 都要想好「誰等它、它何時結束」;sync.WaitGroup.Go(Go 1.25)讓等待更不容易寫錯。
  • Go 1.22 起迴圈變數每次迭代都是新的,閉包可以直接使用;for i := range n 可以直接迭代整數。
  • 多個 goroutine 存取同一記憶體且有寫入時,必須同步;用 go test -race 找出資料競爭,用 Mutex、atomic 或 channel 修正,「檢查後動作」要在同一把鎖內。
  • 無緩衝 channel 讓雙方會合,有緩衝 channel 只吸收短暫的速度差;只由傳送端關閉、只關一次,記住 nil 與已關閉 channel 的行為表。
  • select 用於逾時、非阻塞操作與停止訊號;停止訊號在新程式碼中應改用 context。
  • worker pool 固定並發度,pipeline 串接多個階段;多個傳送者時,用 WaitGroup 等全部結束後再關閉輸出。
  • 有緩衝 channel 可當號誌限制並發數,搭配 errors.Join 收集所有錯誤;實務上常用 errgroup 封裝。
  • goroutine 洩漏來自永遠阻塞的傳送或接收;每個 goroutine 都要有結束條件,並用 goroutine profile 與 testing/synctest 檢查。

下一篇

這篇的並發程式還缺一塊:當請求被客戶端取消、或其中一個下游已經失敗時,沒有一個標準方式通知其他 goroutine「不用做了」,也無法對整條呼叫鏈設定時間上限。下一篇〈context:取消、逾時與資料傳遞〉會用 context 把取消、逾時與請求範圍的資料,從 HTTP 處理器一路傳到每個 goroutine 與下游呼叫。