[TOC]
Golang Context深入理解
Context背景 和 適用場景
golang在1.6.2的時候還沒有自己的context，在1.7的版本中就把golang.org/x/net/context包被加入到了官方的庫中。golang 的 Context包，是專門用來簡化對於處理單個請求的多個goroutine之間與請求域的資料、取消訊號、截止時間等相關操作，這些操作可能涉及多個 API 呼叫。
比如有一個網路請求Request，每個Request都需要開啟一個goroutine做一些事情，這些goroutine又可能會開啟其他的goroutine。這樣的話， 我們就可以通過Context，來跟蹤這些goroutine，並且通過Context來控制他們的目的，這就是Go語言為我們提供的Context，中文可以稱之為“上下文”。
另外一個實際例子是，在Go伺服器程式中，每個請求都會有一個goroutine去處理。然而，處理程式往往還需要建立額外的goroutine去訪問後端資源，比如資料庫、RPC服務等。由於這些goroutine都是在處理同一個請求，所以它們往往需要訪問一些共享的資源，比如使用者身份資訊、認證token、請求截止時間等。而且如果請求超時或者被取消後，所有的goroutine都應該馬上退出並且釋放相關的資源。這種情況也需要用Context來為我們取消掉所有goroutine
如果要使用可以通過 go get golang.org/x/net/context 命令獲取這個包。
Context 定義
ontext的主要資料結構是一種巢狀的結構或者說是單向的繼承關係的結構，比如最初的context是一個小盒子，裡面裝了一些資料，之後從這個context繼承下來的children就像在原本的context中又套上了一個盒子，然後裡面裝著一些自己的資料。或者說context是一種分層的結構，根據使用場景的不同，每一層context都具備有一些不同的特性，這種層級式的組織也使得context易於擴充套件，職責清晰。
context 包的核心是 struct Context，宣告如下：
type Context interface {
Deadline() (deadline time.Time, ok bool)
Done() <-chan struct{}
Err() error
Value(key interface{}) interface{}
}
複製程式碼可以看到Context是一個interface，在golang裡面，interface是一個使用非常廣泛的結構，它可以接納任何型別。Context定義很簡單，一共4個方法，我們需要能夠很好的理解這幾個方法
-
Deadline方法是獲取設定的截止時間的意思，第一個返回式是截止時間，到了這個時間點，Context會自動發起取消請求；第二個返回值ok==false時表示沒有設定截止時間，如果需要取消的話，需要呼叫取消函式進行取消。
-
Done方法返回一個只讀的chan，型別為struct{}，我們在goroutine中，如果該方法返回的chan可以讀取，則意味著parent context已經發起了取消請求，我們通過Done方法收到這個訊號後，就應該做清理操作，然後退出goroutine，釋放資源。之後，Err 方法會返回一個錯誤，告知為什麼 Context 被取消。
-
Err方法返回取消的錯誤原因，因為什麼Context被取消。
-
Value方法獲取該Context上繫結的值，是一個鍵值對，所以要通過一個Key才可以獲取對應的值，這個值一般是執行緒安全的。
Context 的實現方法
Context 雖然是個介面，但是並不需要使用方實現，golang內建的context 包，已經幫我們實現了2個方法，一般在程式碼中，開始上下文的時候都是以這兩個作為最頂層的parent context，然後再衍生出子context。這些 Context 物件形成一棵樹：當一個 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
}
複製程式碼Context 的 繼承
有了如上的根Context，那麼是如何衍生更多的子Context的呢？這就要靠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。
WithDeadline函式，和WithCancel差不多，它會多傳遞一個截止時間引數，意味著到了這個時間點，會自動取消Context，當然我們也可以不等到這個時候，可以提前通過取消函式進行取消。
WithTimeout和WithDeadline基本上一樣，這個表示是超時自動取消，是多少時間後自動取消Context的意思。
WithValue函式和取消Context無關，它是為了生成一個繫結了一個鍵值對資料的Context，這個繫結的資料可以通過Context.Value方法訪問到，這是我們實際用經常要用到的技巧，一般我們想要通過上下文來傳遞資料時，可以通過這個方法，如我們需要tarce追蹤系統呼叫棧的時候。
With 系列函式詳解
WithCancel
context.WithCancel生成了一個withCancel的例項以及一個cancelFuc，這個函式就是用來關閉ctxWithCancel中的 Done channel 函式。
下面來分析下原始碼實現，首先看看初始化，如下：
func newCancelCtx(parent Context) cancelCtx {
return cancelCtx{
Context: parent,
done: make(chan struct{}),
}
}
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
c := newCancelCtx(parent)
propagateCancel(parent, &c)
return &c, func() { c.cancel(true, Canceled) }
}
複製程式碼newCancelCtx返回一個初始化的cancelCtx，cancelCtx結構體繼承了Context，實現了canceler方法：
//*cancelCtx 和 *timerCtx 都實現了canceler介面，實現該介面的型別都可以被直接canceled
type canceler interface {
cancel(removeFromParent bool, err error)
Done() <-chan struct{}
}
type cancelCtx struct {
Context
done chan struct{} // closed by the first cancel call.
mu sync.Mutex
children map[canceler]bool // set to nil by the first cancel call
err error // 當其被cancel時將會把err設定為非nil
}
func (c *cancelCtx) Done() <-chan struct{} {
return c.done
}
func (c *cancelCtx) Err() error {
c.mu.Lock()
defer c.mu.Unlock()
return c.err
}
func (c *cancelCtx) String() string {
return fmt.Sprintf("%v.WithCancel", c.Context)
}
//核心是關閉c.done
//同時會設定c.err = err, c.children = nil
//依次遍歷c.children，每個child分別cancel
//如果設定了removeFromParent，則將c從其parent的children中刪除
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
if err == nil {
panic("context: internal error: missing cancel error")
}
c.mu.Lock()
if c.err != nil {
c.mu.Unlock()
return // already canceled
}
c.err = err
close(c.done)
for child := range c.children {
// NOTE: acquiring the child's lock while holding parent's lock.
child.cancel(false, err)
}
c.children = nil
c.mu.Unlock()
if removeFromParent {
removeChild(c.Context, c) // 從此處可以看到 cancelCtx的Context項是一個類似於parent的概念
}
}
複製程式碼可以看到，所有的children都存在一個map中；Done方法會返回其中的done channel， 而另外的cancel方法會關閉Done channel並且逐層向下遍歷，關閉children的channel，並且將當前canceler從parent中移除。
WithCancel初始化一個cancelCtx的同時，還執行了propagateCancel方法，最後返回一個cancel function。
propagateCancel 方法定義如下：
// propagateCancel arranges for child to be canceled when parent is.
func propagateCancel(parent Context, child canceler) {
if parent.Done() == nil {
return // parent is never canceled
}
if p, ok := parentCancelCtx(parent); ok {
p.mu.Lock()
if p.err != nil {
// parent has already been canceled
child.cancel(false, p.err)
} else {
if p.children == nil {
p.children = make(map[canceler]struct{})
}
p.children[child] = struct{}{}
}
p.mu.Unlock()
} else {
go func() {
select {
case <-parent.Done():
child.cancel(false, parent.Err())
case <-child.Done():
}
}()
}
}
複製程式碼propagateCancel 的含義就是傳遞cancel，從當前傳入的parent開始（包括該parent），向上查詢最近的一個可以被cancel的parent， 如果找到的parent已經被cancel，則將方才傳入的child樹給cancel掉，否則，將child節點直接連線為找到的parent的children中（Context欄位不變，即向上的父親指標不變，但是向下的孩子指標變直接了）； 如果沒有找到最近的可以被cancel的parent，即其上都不可被cancel，則啟動一個goroutine等待傳入的parent終止，則cancel傳入的child樹，或者等待傳入的child終結。
WithDeadLine
在withCancel的基礎上進行的擴充套件，如果時間到了之後就進行cancel的操作，具體的操作流程基本上與withCancel一致，只不過控制cancel函式呼叫的時機是有一個timeout的channel所控制的。
Context 使用原則 和 技巧
- 不要把Context放在結構體中，要以引數的方式傳遞，parent Context一般為Background
- 應該要把Context作為第一個引數傳遞給入口請求和出口請求鏈路上的每一個函式，放在第一位，變數名建議都統一，如ctx。
- 給一個函式方法傳遞Context的時候，不要傳遞nil，否則在tarce追蹤的時候，就會斷了連線
- Context的Value相關方法應該傳遞必須的資料，不要什麼資料都使用這個傳遞
- Context是執行緒安全的，可以放心的在多個goroutine中傳遞
- 可以把一個 Context 物件傳遞給任意個數的 gorotuine，對它執行 取消 操作時，所有 goroutine 都會接收到取消訊號。
Context的常用方法例項
-
呼叫Context Done方法取消
func Stream(ctx context.Context, out chan<- Value) error { for { v, err := DoSomething(ctx) if err != nil { return err } select { case <-ctx.Done(): return ctx.Err() case out <- v: } } } 複製程式碼 -
通過 context.WithValue 來傳值
func main() { ctx, cancel := context.WithCancel(context.Background()) valueCtx := context.WithValue(ctx, key, "add value") go watch(valueCtx) time.Sleep(10 * time.Second) cancel() time.Sleep(5 * time.Second) } func watch(ctx context.Context) { for { select { case <-ctx.Done(): //get value fmt.Println(ctx.Value(key), "is cancel") return default: //get value fmt.Println(ctx.Value(key), "int goroutine") time.Sleep(2 * time.Second) } } } 複製程式碼 -
超時取消 context.WithTimeout
package main import ( "fmt" "sync" "time" "golang.org/x/net/context" ) var ( wg sync.WaitGroup ) func work(ctx context.Context) error { defer wg.Done() for i := 0; i < 1000; i++ { select { case <-time.After(2 * time.Second): fmt.Println("Doing some work ", i) // we received the signal of cancelation in this channel case <-ctx.Done(): fmt.Println("Cancel the context ", i) return ctx.Err() } } return nil } func main() { ctx, cancel := context.WithTimeout(context.Background(), 4*time.Second) defer cancel() fmt.Println("Hey, I'm going to do some work") wg.Add(1) go work(ctx) wg.Wait() fmt.Println("Finished. I'm going home") } 複製程式碼 -
截止時間 取消 context.WithDeadline
package main import ( "context" "fmt" "time" ) func main() { d := time.Now().Add(1 * time.Second) ctx, cancel := context.WithDeadline(context.Background(), d) // Even though ctx will be expired, it is good practice to call its // cancelation function in any case. Failure to do so may keep the // context and its parent alive longer than necessary. defer cancel() select { case <-time.After(2 * time.Second): fmt.Println("oversleep") case <-ctx.Done(): fmt.Println(ctx.Err()) } } 複製程式碼