Skip to main content

[pkg] context

此篇為各筆記之整理,非原創內容,資料來源可見下方連結與文後參考資料:

context package 最重要的就是處理多個 goroutine 的情況,特別是用來送出取消或結束的 signal。

我們可以在一個 goroutine 中建立 Context 物件後,傳入另一個 goroutine;另一個 goroutine 即可以透過 Done() 來從該 context 中取得 signal,一旦這個 Done channel 關閉之後,這個 goroutine 即會關閉並 return。

Context 也可以是受時間控制,它也可以在特定時間後關閉該 signal channel,我們可以定義一個 deadline 或 timeout 的時間,時間到了之後,Context 物件就會關閉該 signal channel。

更好的是,一旦父層的 Context 關閉其 Done channel 之後,子層的 Done channel 則會自動關閉。

重要概念#

  • 不要把 Context 保存在 struct 中,而是直接當作第一個參數傳入 function 或 goroutine 中,通常會命名為 ctx
  • server 在處理傳進來的請求時應該要建立一個 Context,而使用該 server 的方法則應該要接收 Context 作為參數
  • 雖然函式可以允許傳入 nil Context,但千萬不要這麼做,如果你不確定要用哪個 Context,可以使用 context.TODO
  • 只在 request-scoped data 這種要交換處理資料或 API 的範疇下使用 context Values,不要傳入 optional parameters 到函式中。
  • 相同的 Context 可以傳入多個不同的 goroutine 中使用,在多個 goroutines 中同時使用 Context 是安全的(safe)
func DoSomething(ctx context.Context, arg Arg) error {
// ... use ctx ...
}

context.Background()#

context.Background() 會回傳一個不是 nilempty Context這個 Context 絕不會被取消(canceled)、不會有值、也不會有 deadline。這通常會用在 main function、初始化(initialization)或測試中使用,可以作為處理請求時最高層的 Context(top-level Context)。

context.TODO()#

context.TODO() 會回傳一個不是 nil 的 empty Context。它通常會使用在還不清楚要使用哪個 Context 時,或還無法取得 Context 的情況下使用。

context.WithCancel()#

context.WithCancel() 函式會回傳 Context 物件和 CancelFunction。這個 Context 的 Done channel 會在 cancel function 被呼叫到時關閉,或是父層的 Done channel 關閉時亦會關閉。

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
  • 重複呼叫 cancel() 不會有任何效果
  • context 建議當成函式或 goroutine 的參數傳入,並且命名為 ctx,並不建議把它保存在 struct 中
  • Context 可以有父子層的關係,也就是一個 Context 可以產生另一個 Context,但一旦父層 Context 取消/關閉時,所有根據這個 Context 所產生的 Context 也會一併關閉
// https://medium.com/rungo/understanding-the-context-package-b2e407a9cdae
func square(ctx context.Context, c chan int) {
i := 0
for {
select {
case <-ctx.Done(): // STEP 2:監聽 context Done
return // kill goroutine
case c <- i * i:
i++
}
}
}
func main() {
c := make(chan int)
// STEP 1:建立可以被 cancel 的 context
ctx, cancel := context.WithCancel(context.Background())
go square(ctx, c)
for i := 0; i < 5; i++ {
fmt.Println("Next square is", <-c)
}
// STEP 3:當所有訊息都從 channel 取出後,使用 cancel 把 square 這個 goroutine 關閉
cancel()
time.Sleep(3 * time.Second)
fmt.Println("Number of active goroutines", runtime.NumGoroutine())
}

範例:

// code modified from appleboy
// https://blog.wu-boy.com/2020/08/three-ways-to-manage-concurrency-in-go/
func startProcessA(ctx context.Context, name string) {
for {
select {
case <-ctx.Done():
fmt.Println(name, "Exit")
return
case <-time.After(1 * time.Second):
fmt.Println(name, "keep doing something")
}
}
}
func main() {
// 使用 context.WithCancel 取得 ctx 和 cancel
ctx, cancel := context.WithCancel(context.Background())
go startProcessA(ctx, "Process A") // 執行 goroutine 並把 context 傳入
time.Sleep(5 * time.Second)
fmt.Println("client release connection, need to notify Process A and exit")
cancel() // 呼叫 cancel 方法
fmt.Println("Process finish")
}

context.WithDeadline()#

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)
  • context.WithDeadline() 中可以指定一個時間(time.Time)當作 deadline,一旦時間到時,就會自動觸發 cancel
  • context.WithDeadline() 同樣會回傳 cancel,因此也可以主動呼叫 cancel
  • 如果父層的 context 被 cancel 的話,子層的 context 也會一併被 cancel
var startTime = time.Now()
func worker(ctx context.Context, durationSecs int) {
select {
// STEP 3:deadline 時間到時或主動呼叫 cancel 時,都會進入 ctx.Done()
case <-ctx.Done():
fmt.Printf("%0.2fs - worker(%ds) killed!\n", time.Since(startTime).Seconds(), durationSecs)
return // kills goroutine
// 模擬做事所需花費的時間
case <-time.After(time.Duration(durationSecs) * time.Second):
fmt.Printf("%0.2fs - worker(%ds) completed the job.\n", time.Since(startTime).Seconds(), durationSecs)
}
}
func main() {
// STEP 1:建立 deadline
deadline := time.Now().Add(3 * time.Second)
// STEP 2:將 deadline 傳入並取得 cancel
ctx, cancel := context.WithDeadline(context.Background(), deadline)
// STEP 4:如果 main 比其他 goroutine 提早結束時,呼叫 cancel 讓其他 goroutine 結束
defer cancel()
go worker(ctx, 2)
go worker(ctx, 3)
go worker(ctx, 4)
go worker(ctx, 6)
fmt.Println("Number of active goroutines", runtime.NumGoroutine())
time.Sleep(5 * time.Second)
fmt.Println("Number of active goroutines", runtime.NumGoroutine())
}

context.WithTimeout()#

超過一定的時間後就會停止該 function

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
  • context.WithTimeout() 的用法和 context.WithDeadline() 幾乎相同,差別只在於 WithTimeout() 帶入的參數是時間區間(time.Duration
  • 實際上,WithTimeout() 的底層仍然是呼叫 WithDeadline(),只是它會幫忙做掉 time.Add() 的動作
func printFeature(client pb.RouteGuideClient, point *pb.Point) {
// 透過 context.WithTimeout 取得 ctx 和 cancel
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
// 把可能會花許多時間的方法帶入 ctx
feature, err := client.GetFeature(ctx, point)
if err != nil {
log.Fatalf("%v.GetFeature(_) = _, %v: ", client, err)
}
log.Println(feature)
}

context.WithValue()#

func (oAuth *OAuth) GetClient(certPath, keyPath string) (*http.Client, error) {
sslcli, err := addTLSCertificate(certPath, keyPath)
if err != nil {
return nil, fmt.Errorf("add tls certificate %v", err)
}
ctx := context.TODO()
ctx = context.WithValue(ctx, oauth2.HTTPClient, sslcli)
client := oAuth.Config.Client(ctx)
return client, nil
}

參考文章#

Last updated on