從零學習 Go 語言（32）：理解 Go 語言中的 Context

在線博客：http://golang.iswbm.com/

Github：https://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,v)
            return
        default:
            fmt.Printf("監控器%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, deadline time.Time) (Context, CancelFunc)

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

WithDeadline 傳入的第二個參數是 time.Time 類型，它是一個絕對的時間，意思是在什麼時間點超時取消。

而 WithTimeout 傳入的第二個參數是 time.Duration 類型，它是一個相對的時間，意思是多長時間後超時取消。

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())
  
  	// 相比例子1，僅有這一行改動
    ctx02, cancel := context.WithTimeout(ctx01, 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("主程序退出！！")
}

輸出的結果和上面一樣

監控器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 int)  {
    for {
        select {
        case <- ctx.Done():
            fmt.Printf("監控器%v，監控結束。\n", number)
            return
        default:
          	// 獲取 item 的值
            value := ctx.Value("item")
            fmt.Printf("監控器%v，正在監控 %v \n", number, value)
            time.Sleep(2 * time.Second)
        }
    }
}

func main() {
    ctx01, cancel := context.WithCancel(context.Background())
    ctx02, cancel := context.WithTimeout(ctx01, 1* time.Second)
    ctx03 := context.WithValue(ctx02, "item", "CPU")

    defer cancel()

    for i :=1 ; i <= 5; i++ {
        go monitor(ctx03, i)
    }

    time.Sleep(5  * time.Second)
    if ctx02.Err() != nil {
        fmt.Println("監控器取消的原因: ", 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。