深入理解 Go 語言中的 Context
Hi，大家好，我是明哥。
在自己學習 Golang 的這段時間裡，我寫了詳細的學習筆記放在我的個人微信公眾號 《Go程式設計時光》，對於 Go 語言，我也算是個初學者，因此寫的東西應該會比較適合剛接觸的同學，如果你也是剛學習 Go 語言，不防關注一下，一起學習，一起成長。
我的線上部落格：http://golang.iswbm.com
我的 Github：github.com/iswbm/GolangCodingTime
1. 什麼是 Context？
在 Go 1.7 版本之前，context 還是非編制的，它存在於 golang.org/x/net/context 包中。
後來，Golang 團隊發現 context 還挺好用的，就把 context 收編了，在 Go 1.7 版本正式納入了標準庫。
Context，也叫上下文，它的介面定義如下
type Context interface {
Deadline() (deadline time.Time,ok bool)
Done() <-chan struct{}
Err() error
Value(key interface{}) interface{}
}
可以看到 Context 介面共有 4 個方法
Deadline：返回的第一個值是 截止時間，到了這個時間點，Context 會自動觸發 Cancel 動作。返回的第二個值是 一個布林值，true 表示設定了截止時間，false 表示沒有設定截止時間，如果沒有設定截止時間，就要手動呼叫 cancel 函式取消 Context。Done：返回一個只讀的通道（只有在被cancel後才會返回），型別為struct{}。當這個通道可讀時，意味著parent context已經發起了取消請求，根據這個訊號，開發者就可以做一些清理動作，退出goroutine。Err：返回 context 被 cancel 的原因。Value：返回被繫結到 Context 的值，是一個鍵值對，所以要通過一個Key才可以獲取對應的值，這個值一般是執行緒安全的。
2. 為何需要 Context？
當一個協程（goroutine）開啟後，我們是無法強制關閉它的。
常見的關閉協程的原因有如下幾種：
- goroutine 自己跑完結束退出
- 主程序crash退出，goroutine 被迫退出
- 通過通道傳送訊號，引導協程的關閉。
第一種，屬於正常關閉，不在今天討論範圍之內。
第二種，屬於異常關閉，應當優化程式碼。
第三種，才是開發者可以手動控制協程的方法，程式碼示例如下：
func main() {
stop := make(chan bool)
go func() {
for {
select {
case <-stop:
fmt.Println("監控退出，停止了...")
return
default:
fmt.Println("goroutine監控中...")
time.Sleep(2 * time.Second)
}
}
}()
time.Sleep(10 * time.Second)
fmt.Println("可以了，通知監控停止")
stop<- true
//為了檢測監控過是否停止，如果沒有監控輸出，就表示停止了
time.Sleep(5 * time.Second)
}
例子中我們定義一個stop的chan，通知他結束後臺goroutine。實現也非常簡單，在後臺goroutine中，使用select判斷stop是否可以接收到值，如果可以接收到，就表示可以退出停止了；如果沒有接收到，就會執行default裡的監控邏輯，繼續監控，只到收到stop的通知。
以上是一個 goroutine 的場景，如果是多個 goroutine ，每個goroutine 底下又開啟了多個 goroutine 的場景呢？在 飛雪無情的部落格 裡關於為何要使用 Context，他是這麼說的
chan+select的方式，是比較優雅的結束一個goroutine的方式，不過這種方式也有侷限性，如果有很多goroutine都需要控制結束怎麼辦呢？如果這些goroutine又衍生了其他更多的goroutine怎麼辦呢？如果一層層的無窮盡的goroutine呢？這就非常複雜了，即使我們定義很多chan也很難解決這個問題，因為goroutine的關係鏈就導致了這種場景非常複雜。
在這裡我不是很贊同他說的話，因為我覺得就算只使用一個通道也能達到控制（取消）多個 goroutine 的目的。下面就用例子來驗證一下。
該例子的原理是：使用 close 關閉通道後，如果該通道是無緩衝的，則它會從原來的阻塞變成非阻塞，也就是可讀的，只不過讀到的會一直是零值，因此根據這個特性就可以判斷 擁有該通道的 goroutine 是否要關閉。
package main
import (
"fmt"
"time"
)
func monitor(ch chan bool,number int) {
for {
select {
case v := <-ch:
// 僅當 ch 通道被 close，或者有資料發過來(無論是true還是false)才會走到這個分支
fmt.Printf("監控器%v，接收到通道值為：%v，監控結束。\n",number,v)
return
default:
fmt.Printf("監控器%v，正在監控中...\n",number)
time.Sleep(2 * time.Second)
}
}
}
func main() {
stopSingal := make(chan bool)
for i :=1 ; i <= 5; i++ {
go monitor(stopSingal,i)
}
time.Sleep( 1 * time.Second)
// 關閉所有 goroutine
close(stopSingal)
// 等待5s，若此時螢幕沒有輸出 <正在監控中> 就說明所有的goroutine都已經關閉
time.Sleep( 5 * time.Second)
fmt.Println("主程式退出！！")
}
輸出如下
監控器4，正在監控中...
監控器1，正在監控中...
監控器2，正在監控中...
監控器3，正在監控中...
監控器5，正在監控中...
監控器2，接收到通道值為：false，監控結束。
監控器3，接收到通道值為：false，監控結束。
監控器5，接收到通道值為：false，監控結束。
監控器1，接收到通道值為：false，監控結束。
監控器4，接收到通道值為：false，監控結束。
主程式退出！！
上面的例子，說明當我們定義一個無緩衝通道時，如果要對所有的 goroutine 進行關閉，可以使用 close 關閉通道，然後在所有的 goroutine 裡不斷檢查通道是否關閉(前提你得約定好，該通道你只會進行 close 而不會發送其他資料，否則傳送一次資料就會關閉一個goroutine，這樣會不符合咱們的預期，所以最好你對這個通道再做一層封裝做個限制)來決定是否結束 goroutine。
所以你看到這裡，我做為初學者還是沒有找到使用 Context 的必然理由，我只能說 Context 是個很好用的東西，使用它方便了我們在處理併發時候的一些問題，但是它並不是不可或缺的。
換句話說，它解決的並不是 能不能 的問題，而是解決 更好用 的問題。
3. 簡單使用 Context
如果不使用上面 close 通道的方式，還有沒有其他更優雅的方法來實現呢？
有，那就是本文要講的 Context
我使用 Context 對上面的例子進行了一番改造。
package main
import (
"context"
"fmt"
"time"
)
func monitor(ctx context.Context,number int) {
for {
select {
// 其實可以寫成 case <- ctx.Done()
// 這裡僅是為了讓你看到 Done 返回的內容
case v :=<- ctx.Done():
fmt.Printf("監控器%v，接收到通道值為：%v，監控結束。\n",number)
time.Sleep(2 * time.Second)
}
}
}
func main() {
ctx,cancel := context.WithCancel(context.Background())
for i :=1 ; i <= 5; i++ {
go monitor(ctx,i)
}
time.Sleep( 1 * time.Second)
// 關閉所有 goroutine
cancel()
// 等待5s，若此時螢幕沒有輸出 <正在監控中> 就說明所有的goroutine都已經關閉
time.Sleep( 5 * time.Second)
fmt.Println("主程式退出！！")
}
這裡面的關鍵程式碼，也就三行
第一行：以 context.Background() 為 parent context 定義一個可取消的 context
ctx,cancel := context.WithCancel(context.Background())
第二行：然後你可以在所有的goroutine 裡利用 for + select 搭配來不斷檢查 ctx.Done() 是否可讀，可讀就說明該 context 已經取消，你可以清理 goroutine 並退出了。
case <- ctx.Done():
第三行：當你想到取消 context 的時候，只要呼叫一下 cancel 方法即可。這個 cancel 就是我們在建立 ctx 的時候返回的第二個值。
cancel()
執行結果輸出如下。可以發現我們實現了和 close 通道一樣的效果。
監控器3，正在監控中...
監控器4，正在監控中...
監控器1，正在監控中...
監控器2，正在監控中...
監控器2，接收到通道值為：{}，監控結束。
監控器5，接收到通道值為：{}，監控結束。
監控器4，接收到通道值為：{}，監控結束。
監控器1，接收到通道值為：{}，監控結束。
監控器3，接收到通道值為：{}，監控結束。
主程式退出！！
4. 根Context 是什麼？
建立 Context 必須要指定一個 父 Context，當我們要建立第一個Context時該怎麼辦呢？
不用擔心，Go 已經幫我們實現了2個，我們程式碼中最開始都是以這兩個內建的context作為最頂層的parent context，衍生出更多的子Context。
var (
background = new(emptyCtx)
todo = new(emptyCtx)
)
func Background() Context {
return background
}
func TODO() Context {
return todo
}
一個是Background，主要用於main函式、初始化以及測試程式碼中，作為Context這個樹結構的最頂層的Context，也就是根Context，它不能被取消。
一個是TODO，如果我們不知道該使用什麼Context的時候，可以使用這個，但是實際應用中，暫時還沒有使用過這個TODO。
他們兩個本質上都是emptyCtx結構體型別，是一個不可取消，沒有設定截止時間，沒有攜帶任何值的Context。
type emptyCtx int
func (*emptyCtx) Deadline() (deadline time.Time,ok bool) {
return
}
func (*emptyCtx) Done() <-chan struct{} {
return nil
}
func (*emptyCtx) Err() error {
return nil
}
func (*emptyCtx) Value(key interface{}) interface{} {
return nil
}
5. Context 的繼承衍生
上面在定義我們自己的 Context 時，我們使用的是 WithCancel 這個方法。
除它之外，context 包還有其他幾個 With 系列的函式
func WithCancel(parent Context) (ctx Context,cancel CancelFunc)
func WithDeadline(parent Context,deadline time.Time) (Context,CancelFunc)
func WithTimeout(parent Context,timeout time.Duration) (Context,CancelFunc)
func WithValue(parent Context,key,val interface{}) Context
這四個函式有一個共同的特點，就是第一個引數，都是接收一個 父context。
通過一次繼承，就多實現了一個功能，比如使用 WithCancel 函式傳入 根context ，就創建出了一個子 context，該子context 相比 父context，就多了一個 cancel context 的功能。
如果此時，我們再以上面的子context（context01）做為父context，並將它做為第一個引數傳入WithDeadline函式，獲得的子子context（context02），相比子context（context01）而言，又多出了一個超過 deadline 時間後，自動 cancel context 的功能。
接下來我會舉例介紹一下這幾種 context，其中 WithCancel 在上面已經講過了，下面就不再舉例了
例子 1：WithDeadline
package main
import (
"context"
"fmt"
"time"
)
func monitor(ctx context.Context,number int) {
for {
select {
case <- ctx.Done():
fmt.Printf("監控器%v，監控結束。\n",number)
return
default:
fmt.Printf("監控器%v，正在監控中...\n",number)
time.Sleep(2 * time.Second)
}
}
}
func main() {
ctx01,cancel := context.WithCancel(context.Background())
ctx02,cancel := context.WithDeadline(ctx01,time.Now().Add(1 * time.Second))
defer cancel()
for i :=1 ; i <= 5; i++ {
go monitor(ctx02,i)
}
time.Sleep(5 * time.Second)
if ctx02.Err() != nil {
fmt.Println("監控器取消的原因: ",ctx02.Err())
}
fmt.Println("主程式退出！！")
}
輸出如下
監控器5，正在監控中...
監控器1，正在監控中...
監控器2，正在監控中...
監控器3，正在監控中...
監控器4，正在監控中...
監控器3，監控結束。
監控器4，監控結束。
監控器2，監控結束。
監控器1，監控結束。
監控器5，監控結束。
監控器取消的原因: context deadline exceeded
主程式退出！！
例子 2：WithTimeout
WithTimeout 和 WithDeadline 使用方法及功能基本一致，都是表示超過一定的時間會自動 cancel context。
唯一不同的地方，我們可以從函式的定義看出
func WithDeadline(parent Context,CancelFunc) func WithTimeout(parent Context,CancelFunc)
WithDeadline 傳入的第二個引數是 time.Time 型別，它是一個絕對的時間，意思是在什麼時間點超時取消。
而 WithTimeout 傳入的第二個引數是 time.Duration 型別，它是一個相對的時間，意思是多長時間後超時取消。
package main
import (
"context"
"fmt"
"time"
)
func monitor(ctx context.Context,cancel := context.WithCancel(context.Background())
// 相比例子1，僅有這一行改動
ctx02,cancel := context.WithTimeout(ctx01,1* time.Second)
defer cancel()
for i :=1 ; i <= 5; i++ {
go monitor(ctx02,ctx02.Err())
}
fmt.Println("主程式退出！！")
}
輸出的結果和上面一樣
監控器1，正在監控中...
監控器5，正在監控中...
監控器3，正在監控中...
監控器2，正在監控中...
監控器4，正在監控中...
監控器4，監控結束。
監控器2，監控結束。
監控器5，監控結束。
監控器1，監控結束。
監控器3，監控結束。
監控器取消的原因: context deadline exceeded
主程式退出！！
例子 3：WithValue
通過Context我們也可以傳遞一些必須的元資料，這些資料會附加在Context上以供使用。
元資料以 Key-Value 的方式傳入，Key 必須有可比性，Value 必須是執行緒安全的。
還是用上面的例子，以 ctx02 為父 context，再建立一個能攜帶 value 的ctx03，由於他的父context 是 ctx02，所以 ctx03 也具備超時自動取消的功能。
package main
import (
"context"
"fmt"
"time"
)
func monitor(ctx context.Context,number)
return
default:
// 獲取 item 的值
value := ctx.Value("item")
fmt.Printf("監控器%v，正在監控 %v \n",value)
time.Sleep(2 * time.Second)
}
}
}
func main() {
ctx01,1* time.Second)
ctx03 := context.WithValue(ctx02,"item","CPU")
defer cancel()
for i :=1 ; i <= 5; i++ {
go monitor(ctx03,ctx02.Err())
}
fmt.Println("主程式退出！！")
}
輸出如下
監控器4，正在監控 CPU
監控器5，正在監控 CPU
監控器1，正在監控 CPU
監控器3，正在監控 CPU
監控器2，正在監控 CPU
監控器2，監控結束。
監控器5，監控結束。
監控器3，監控結束。
監控器1，監控結束。
監控器4，監控結束。
監控器取消的原因: context deadline exceeded
主程式退出！！
6. Context 使用注意事項
- 通常 Context 都是做為函式的第一個引數進行傳遞（規範性做法），並且變數名建議統一叫 ctx
- Context 是執行緒安全的，可以放心地在多個 goroutine 中使用。
- 當你把 Context 傳遞給多個 goroutine 使用時，只要執行一次 cancel 操作，所有的 goroutine 就可以收到 取消的訊號
- 不要把原本可以由函式引數來傳遞的變數，交給 Context 的 Value 來傳遞。
- 當一個函式需要接收一個 Context 時，但是此時你還不知道要傳遞什麼 Context 時，可以先用 context.TODO 來代替，而不要選擇傳遞一個 nil。
- 當一個 Context 被 cancel 時，繼承自該 Context 的所有 子 Context 都會被 cancel。
總結
到此這篇關於深入理解 Go 語言中的 Context的文章就介紹到這了,更多相關Go 語言 Context內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！