context包

Jeff的技術棧 發表於 2022-01-22

Context包到底是幹嘛用的?

我們會在用到很多東西的時候都看到context的影子,比如gin框架,比如grpc,這東西到底是做啥的?
大家都在用,沒幾個知道這是幹嘛的,知其然而不知其所以然

原理說白了就是:

  1. 當前協程取消了,可以通知所有由它建立的子協程退出
  2. 當前協程取消了,不會影響到建立它的父級協程的狀態
  3. 擴充套件了額外的功能:超時取消、定時取消、可以和子協程共享資料

context原理

這就是context包的核心原理,鏈式傳遞context,基於context構造新的context

什麼時候應該使用 Context?

  • 每一個 RPC 呼叫都應該有超時退出的能力,這是比較合理的 API 設計
  • 不僅僅 是超時,你還需要有能力去結束那些不再需要操作的行為
  • context.Context 是 Go 標準的解決方案
  • 任何函式可能被阻塞,或者需要很長時間來完成的,都應該有個 context.Context

如何建立 Context?

  • 在 RPC 開始的時候,使用 context.Background()
    • 有些人把在 main() 裡記錄一個 context.Background(),然後把這個放到伺服器的某個變數裡,然後請求來了後從這個變數裡繼承 context。這麼做是不對的。直接每個請求,源自自己的 context.Background() 即可。
  • 如果你沒有 context,卻需要呼叫一個 context 的函式的話,用 context.TODO()
  • 如果某步操作需要自己的超時設定的話,給它一個獨立的 sub-context(如前面的例子)

主協程通知有子協程,子協程又有多個子協程

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    //緩衝通道預先放置10個訊息
    messages := make(chan int, 10)
    defer close(messages)
    for i := 0; i < 10; i++ {
        messages <- i
    }
    //啟動3個子協程消費messages訊息
    for i := 1; i <= 3; i++ {
        go child(i, ctx, messages)
    }
    time.Sleep(3 * time.Second) //等待子協程接收一半的訊息
    cancel() //結束前通知子協程
    time.Sleep(2 * time.Second) //等待所有的子協程輸出
    fmt.Println("主協程結束")
}

//從messages通道獲取資訊,當收到結束訊號的時候不再接收
func child(i int, ctx context.Context, messages <-chan int) {
    //基於父級的context建立context
    newCtx, _ := context.WithCancel(ctx)
    go childJob(i, "a", newCtx)
    go childJob(i, "b", newCtx)

Consume:
    for {
        time.Sleep(1 * time.Second)
        select {
        case <-ctx.Done():
            fmt.Printf("[%d]被主協程通知結束...\n", i)
            break Consume
        default:
            fmt.Printf("[%d]接收訊息: %d\n", i, <-messages)
        }
    }
}

//任務
func childJob(parent int, name string, ctx context.Context) {
    for {
        time.Sleep(1 * time.Second)
        select {
        case <-ctx.Done():
            fmt.Printf("[%d-%v]被結束...\n", parent, name)
            return
        default:
            fmt.Printf("[%d-%v]執行\n", parent, name)
        }
    }
}

執行結果如下
img

可以看到,改成context包還是順利的通過子協程退出了
主要修改了幾個地方,再ctx向下傳遞
img

基於上層context再構建當前層級的context
img

監聽context的退出訊號,
img

這就是context包的核心原理,鏈式傳遞context,基於context構造新的context

context核心介面

type Context interface {

    Deadline() (deadline time.Time, ok bool)

    Done() <-chan struct{}

    Err() error

    Value(key interface{}) interface{}
}
Deadline返回繫結當前context的任務被取消的截止時間;如果沒有設定期限,將返回ok == false。

Done 當繫結當前context的任務被取消時,將返回一個關閉的channel;如果當前context不會被取消,將返回nil。

Err 如果Done返回的channel沒有關閉,將返回nil;如果Done返回的channel已經關閉,將返回非空的值表示任務結束的原因。如果是context被取消,Err將返回Canceled;如果是context超時,Err將返回DeadlineExceeded。

Value 返回context儲存的鍵值對中當前key對應的值,如果沒有對應的key,則返回nil。

emptyCtx結構體

實現了context介面,emptyCtx沒有超時時間,不能取消,也不能儲存額外資訊,所以emptyCtx用來做根節點,一般用Background和TODO來初始化emptyCtx

Backgroud

通常用於主函式,初始化以及測試,作為頂層的context

context.Background()

TODO

不確定使用什麼用context的時候才會使用

valueCtx結構體

type valueCtx struct{ Context key, val interface{} }

valueCtx利用Context的變數來表示父節點context,所以當前context繼承了父context的所有資訊
valueCtx還可以儲存鍵值。

WithValue向context新增值

可以向context新增鍵值

func WithValue(parent Context, key, val interface{}) Context {
    if key == nil {
        panic("nil key")
    }
    if !reflect.TypeOf(key).Comparable() {
        panic("key is not comparable")
    }
    return &valueCtx{parent, key, val}
}

新增鍵值會返回建立一個新的valueCtx子節點

Value向context取值

func (c *valueCtx) Value(key interface{}) interface{} {
    if c.key == key {
        return c.val
    }
    return c.Context.Value(key)
}

可以用來獲取當前context和所有的父節點儲存的key

如果當前的context不存在需要的key,會沿著context鏈向上尋找key對應的值,直到根節點

示例

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	ctx := context.WithValue(context.Background(), "name1", "root1")

	//第一層
	go func(parent context.Context) {
		ctx = context.WithValue(parent, "name2", "root2")
		//第二層
		go func(parent context.Context) {
			ctx = context.WithValue(parent, "name3", "root3")
			//第三層
			go func(parent context.Context) {
				//可以獲取所有的父類的值
				fmt.Println(ctx.Value("name1"))
				fmt.Println(ctx.Value("name2"))
				fmt.Println(ctx.Value("name3"))
				//不存在
				fmt.Println(ctx.Value("name4"))
			}(ctx)
		}(ctx)
	}(ctx)
	time.Sleep(1 * time.Second)
	fmt.Println("end")
}

執行結果

context包

可以看到,子context是可以獲取所有父級設定過的key

WithCancel可取消的context

用來建立一個可取消的context,返回一個context和一個CancelFunc,呼叫CancelFunc可以觸發cancel操作。

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	//第一層
	go func(parent context.Context) {
		ctx, _ := context.WithCancel(parent)
		//第二層
		go func(parent context.Context) {
			ctx, _ := context.WithCancel(parent)
			//第三層
			go func(parent context.Context) {
				waitCancel(ctx, 3)
			}(ctx)
			waitCancel(ctx, 2)
		}(ctx)
		waitCancel(ctx, 1)
	}(ctx)
	// 主執行緒給的結束時間
	time.Sleep(2 * time.Second)
	cancel() // 呼叫取消context
	time.Sleep(1 * time.Second)
}

func waitCancel(ctx context.Context, i int) {
	for {
		time.Sleep(time.Second)
		select {
		case <-ctx.Done():
			fmt.Printf("%d end\n", i)
			return
		default:
			fmt.Printf("%d do\n", i)
		}
	}
}

結果:

context包

cancelCtx結構體

type cancelCtx struct {
    Context
    mu sync.Mutex
    done chan struct{}
    children map[canceler]struct{}
    err error
}
type canceler interface {
    cancel(removeFromParent bool, err error)
    Done() <-chan struct{}
}

WithDeadline-超時取消context

返回一個基於parent的可取消的context,並且過期時間deadline不晚於所設定時間d

WithTimeout-超時取消context

建立一個定時取消context,和WithDeadline差不多,WithTimeout是相對時間

timerCtx結構體

timerCtx是基於cancelCtx的context精英,是一種可以定時取消的context,過期時間的deadline不晚於所設定的時間d

示例:

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	// 設定超時時間
	ctx, _ := context.WithTimeout(context.Background(), 2*time.Second)
	//第一層
	go func(parent context.Context) {
		ctx, _ := context.WithCancel(parent)
		//第二層
		go func(parent context.Context) {
			ctx, _ := context.WithCancel(parent)
			//第三層
			go func(parent context.Context) {
				waitCancel(ctx, 3)
			}(ctx)
			waitCancel(ctx, 2)
		}(ctx)
		waitCancel(ctx, 1)
	}(ctx)

	<-ctx.Done()
	// 給時間呼叫end
	time.Sleep(time.Second)
}

func waitCancel(ctx context.Context, i int) {
	for {
		time.Sleep(time.Second)
		select {
		case <-ctx.Done():
			fmt.Printf("%d end\n", i)
			return
		default:
			fmt.Printf("%d do\n", i)
		}
	}
}

執行結果:

1 do
3 do
2 do
1 end
3 end
2 end

可以看到,雖然我們沒有呼叫cancel方法,5秒後自動呼叫了,所有的子goroutine都已經收到停止訊號

總結核心原理

  1. Done方法返回一個channel
  2. 外部通過呼叫<-channel監聽cancel方法
  3. cancel方法會呼叫close(channel)
    當呼叫close方法的時候,所有的channel再次從通道獲取內容,會返回零值和false
res,ok := <-done:
  1. 過期自動取消,使用了time.AfterFunc方法,到時呼叫cancel方法
  c.timer = time.AfterFunc(dur, func() {
   c.cancel(true, DeadlineExceeded)
  })