Go標準庫Context

時間  2019-11-07
標籤 標準 context 简体版
原文   原文鏈接

Go標準庫Context

在 Go http包的Server中，每個請求在都有一個對應的 goroutine 去處理。請求處理函數一般會啓動額外的 goroutine 用來訪問後端服務，好比數據庫和RPC服務。用來處理一個請求的 goroutine 一般須要訪問一些與請求特定的數據，好比終端用戶的身份認證信息、驗證相關的token、請求的截止時間。 當一個請求被取消或超時時，全部用來處理該請求的 goroutine 都應該迅速退出，而後系統才能釋放這些 goroutine 佔用的資源。數據庫

爲何須要Context

基本示例

package main

import (
    "fmt"
    "sync"

    "time"
)

var wg sync.WaitGroup

// 初始的例子

func worker() {
    for {
        fmt.Println("worker")
        time.Sleep(time.Second)
    }
    // 如何接收外部命令實現退出
    wg.Done()
}

func main() {
    wg.Add(1)
    go worker()
    // 如何優雅的實現結束子goroutine
    wg.Wait()
    fmt.Println("over")
}

全局變量方式

package main

import (
    "fmt"
    "sync"

    "time"
)

var wg sync.WaitGroup
var exit bool

// 全局變量方式存在的問題：
// 1. 使用全局變量在跨包調用時不容易統一
// 2. 若是worker中再啓動goroutine，就不太好控制了。

func worker() {
    for {
        fmt.Println("worker")
        time.Sleep(time.Second)
        if exit {
            break
        }
    }
    wg.Done()
}

func main() {
    wg.Add(1)
    go worker()
    time.Sleep(time.Second * 3) // sleep3秒以避免程序過快退出
    exit = true                 // 修改全局變量實現子goroutine的退出
    wg.Wait()
    fmt.Println("over")
}

通道方式

package main

import (
    "fmt"
    "sync"

    "time"
)

var wg sync.WaitGroup

// 管道方式存在的問題：
// 1. 使用全局變量在跨包調用時不容易實現規範和統一，須要維護一個共用的channel

func worker(exitChan chan struct{}) {
LOOP:
    for {
        fmt.Println("worker")
        time.Sleep(time.Second)
        select {
        case <-exitChan: // 等待接收上級通知
            break LOOP
        default:
        }
    }
    wg.Done()
}

func main() {
    var exitChan = make(chan struct{})
    wg.Add(1)
    go worker(exitChan)
    time.Sleep(time.Second * 3) // sleep3秒以避免程序過快退出
    exitChan <- struct{}{}      // 給子goroutine發送退出信號
    close(exitChan)
    wg.Wait()
    fmt.Println("over")
}

官方版的方案

package main

import (
    "context"
    "fmt"
    "sync"

    "time"
)

var wg sync.WaitGroup

func worker(ctx context.Context) {
LOOP:
    for {
        fmt.Println("worker")
        time.Sleep(time.Second)
        select {
        case <-ctx.Done(): // 等待上級通知
            break LOOP
        default:
        }
    }
    wg.Done()
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    wg.Add(1)
    go worker(ctx)
    time.Sleep(time.Second * 3)
    cancel() // 通知子goroutine結束
    wg.Wait()
    fmt.Println("over")
}

當子goroutine又開啓另一個goroutine時，只須要將ctx傳入便可：後端

package main

import (
    "context"
    "fmt"
    "sync"

    "time"
)

var wg sync.WaitGroup

func worker(ctx context.Context) {
    go worker2(ctx)
LOOP:
    for {
        fmt.Println("worker")
        time.Sleep(time.Second)
        select {
        case <-ctx.Done(): // 等待上級通知
            break LOOP
        default:
        }
    }
    wg.Done()
}

func worker2(ctx context.Context) {
LOOP:
    for {
        fmt.Println("worker2")
        time.Sleep(time.Second)
        select {
        case <-ctx.Done(): // 等待上級通知
            break LOOP
        default:
        }
    }
}
func main() {
    ctx, cancel := context.WithCancel(context.Background())
    wg.Add(1)
    go worker(ctx)
    time.Sleep(time.Second * 3)
    cancel() // 通知子goroutine結束
    wg.Wait()
    fmt.Println("over")
}

Context初識

Go1.7加入了一個新的標準庫context，它定義了Context類型，專門用來簡化 對於處理單個請求的多個 goroutine 之間與請求域的數據、取消信號、截止時間等相關操做，這些操做可能涉及多個 API 調用。api

對服務器傳入的請求應該建立上下文，而對服務器的傳出調用應該接受上下文。它們之間的函數調用鏈必須傳遞上下文，或者可使用WithCancel、WithDeadline、WithTimeout或WithValue建立的派生上下文。當一個上下文被取消時，它派生的全部上下文也被取消。安全

Context接口

context.Context是一個接口，該接口定義了四個須要實現的方法。具體簽名以下：服務器

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
}

其中：網絡

  1. Deadline方法須要返回當前Context被取消的時間，也就是完成工做的截止時間（deadline）；

  2. Done方法須要返回一個Channel，這個Channel會在當前工做完成或者上下文被取消以後關閉，屢次調用Done方法會返回同一個Channel；函數

  3. Err方法會返回當前Context結束的緣由，它只會在Done返回的Channel被關閉時纔會返回非空的值；測試

  • 若是當前Context被取消就會返回Canceled錯誤；
  • 若是當前Context超時就會返回DeadlineExceeded錯誤；
  1. Value方法會從Context中返回鍵對應的值，對於同一個上下文來講，屢次調用Value 並傳入相同的Key會返回相同的結果，該方法僅用於傳遞跨API和進程間跟請求域的數據；

Background()和TODO()

Go內置兩個函數：Background()和TODO()，這兩個函數分別返回一個實現了Context接口的background和todo。咱們代碼中最開始都是以這兩個內置的上下文對象做爲最頂層的partent context，衍生出更多的子上下文對象。ui

Background()主要用於main函數、初始化以及測試代碼中，做爲Context這個樹結構的最頂層的Context，也就是根Context。線程

TODO()，它目前還不知道具體的使用場景，若是咱們不知道該使用什麼Context的時候，可使用這個。

background和todo本質上都是emptyCtx結構體類型，是一個不可取消，沒有設置截止時間，沒有攜帶任何值的Context。

With系列函數

此外，context包中還定義了四個With系列函數。

WithCancel

WithCancel的函數簽名以下：

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

WithCancel返回帶有新Done通道的父節點的副本。當調用返回的cancel函數或當關閉父上下文的Done通道時，將關閉返回上下文的Done通道，不管先發生什麼狀況。

取消此上下文將釋放與其關聯的資源，所以代碼應該在此上下文中運行的操做完成後當即調用cancel。

func gen(ctx context.Context) <-chan int {
        dst := make(chan int)
        n := 1
        go func() {
            for {
                select {
                case <-ctx.Done():
                    return // return結束該goroutine，防止泄露
                case dst <- n:
                    n++
                }
            }
        }()
        return dst
    }
func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // 當咱們取完須要的整數後調用cancel

    for n := range gen(ctx) {
        fmt.Println(n)
        if n == 5 {
            break
        }
    }
}

上面的示例代碼中，gen函數在單獨的goroutine中生成整數並將它們發送到返回的通道。 gen的調用者在使用生成的整數以後須要取消上下文，以避免gen啓動的內部goroutine發生泄漏。

WithDeadline

WithDeadline的函數簽名以下：

func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
返回父上下文的副本，並將deadline調整爲不遲於d。若是父上下文的deadline已經早於d，則WithDeadline(parent, d)在語義上等同於父上下文。當截止日過時時，當調用返回的cancel函數時，或者當父上下文的Done通道關閉時，返回上下文的Done通道將被關閉，以最早發生的狀況爲準。

取消此上下文將釋放與其關聯的資源，所以代碼應該在此上下文中運行的操做完成後當即調用cancel。

​```go
func main() {
    d := time.Now().Add(50 * time.Millisecond)
    ctx, cancel := context.WithDeadline(context.Background(), d)

    // 儘管ctx會過時，但在任何狀況下調用它的cancel函數都是很好的實踐。
    // 若是不這樣作，可能會使上下文及其父類存活的時間超過必要的時間。
    defer cancel()

    select {
    case <-time.After(1 * time.Second):
        fmt.Println("overslept")
    case <-ctx.Done():
        fmt.Println(ctx.Err())
    }
}

上面的代碼中，定義了一個50毫秒以後過時的deadline，而後咱們調用context.WithDeadline(context.Background(), d)獲得一個上下文（ctx）和一個取消函數（cancel），而後使用一個select讓主程序陷入等待：等待1秒後打印overslept退出或者等待ctx過時後退出。 由於ctx50秒後就過時，因此ctx.Done()會先接收到值，上面的代碼會打印ctx.Err()取消緣由。

WithTimeout

WithTimeout的函數簽名以下：

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

WithTimeout返回WithDeadline(parent, time.Now().Add(timeout))。

取消此上下文將釋放與其相關的資源，所以代碼應該在此上下文中運行的操做完成後當即調用cancel，一般用於數據庫或者網絡鏈接的超時控制。具體示例以下：

package main

import (
    "context"
    "fmt"
    "sync"

    "time"
)

// context.WithTimeout

var wg sync.WaitGroup

func worker(ctx context.Context) {
LOOP:
    for {
        fmt.Println("db connecting ...")
        time.Sleep(time.Millisecond * 10) // 假設正常鏈接數據庫耗時10毫秒
        select {
        case <-ctx.Done(): // 50毫秒後自動調用
            break LOOP
        default:
        }
    }
    fmt.Println("worker done!")
    wg.Done()
}

func main() {
    // 設置一個50毫秒的超時
    ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
    wg.Add(1)
    go worker(ctx)
    time.Sleep(time.Second * 5)
    cancel() // 通知子goroutine結束
    wg.Wait()
    fmt.Println("over")
}

WithValue

WithValue函數可以將請求做用域的數據與 Context 對象創建關係。聲明以下：

func WithValue(parent Context, key, val interface{}) Context

WithValue返回父節點的副本，其中與key關聯的值爲val。

僅對API和進程間傳遞請求域的數據使用上下文值，而不是使用它來傳遞可選參數給函數。

所提供的鍵必須是可比較的，而且不該該是string類型或任何其餘內置類型，以免使用上下文在包之間發生衝突。WithValue的用戶應該爲鍵定義本身的類型。爲了不在分配給interface{}時進行分配，上下文鍵一般具備具體類型struct{}。或者，導出的上下文關鍵變量的靜態類型應該是指針或接口。

package main

import (
    "context"
    "fmt"
    "sync"

    "time"
)

// context.WithValue

type TraceCode string

var wg sync.WaitGroup

func worker(ctx context.Context) {
    key := TraceCode("TRACE_CODE")
    traceCode, ok := ctx.Value(key).(string) // 在子goroutine中獲取trace code
    if !ok {
        fmt.Println("invalid trace code")
    }
LOOP:
    for {
        fmt.Printf("worker, trace code:%s\n", traceCode)
        time.Sleep(time.Millisecond * 10) // 假設正常鏈接數據庫耗時10毫秒
        select {
        case <-ctx.Done(): // 50毫秒後自動調用
            break LOOP
        default:
        }
    }
    fmt.Println("worker done!")
    wg.Done()
}

func main() {
    // 設置一個50毫秒的超時
    ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
    // 在系統的入口中設置trace code傳遞給後續啓動的goroutine實現日誌數據聚合
    ctx = context.WithValue(ctx, TraceCode("TRACE_CODE"), "12512312234")
    wg.Add(1)
    go worker(ctx)
    time.Sleep(time.Second * 5)
    cancel() // 通知子goroutine結束
    wg.Wait()
    fmt.Println("over")
}

使用Context的注意事項

  • 推薦以參數的方式顯示傳遞Context
  • 以Context做爲參數的函數方法，應該把Context做爲第一個參數。
  • 給一個函數方法傳遞Context的時候，不要傳遞nil，若是不知道傳遞什麼，就使用context.TODO()
  • Context的Value相關方法應該傳遞請求域的必要數據，不該該用於傳遞可選參數
  • Context是線程安全的，能夠放心的在多個goroutine中傳遞

客戶端超時取消示例

調用服務端API時如何在客戶端實現超時控制？

server端

// context_timeout/server/main.go
package main

import (
    "fmt"
    "math/rand"
    "net/http"

    "time"
)

// server端，隨機出現慢響應

func indexHandler(w http.ResponseWriter, r *http.Request) {
    number := rand.Intn(2)
    if number == 0 {
        time.Sleep(time.Second * 10) // 耗時10秒的慢響應
        fmt.Fprintf(w, "slow response")
        return
    }
    fmt.Fprint(w, "quick response")
}

func main() {
    http.HandleFunc("/", indexHandler)
    err := http.ListenAndServe(":8000", nil)
    if err != nil {
        panic(err)
    }
}

client端

// context_timeout/client/main.go
package main

import (
    "context"
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
    "time"
)

// 客戶端

type respData struct {
    resp *http.Response
    err  error
}

func doCall(ctx context.Context) {
    transport := http.Transport{
       // 請求頻繁可定義全局的client對象並啓用長連接
       // 請求不頻繁使用短連接
       DisableKeepAlives: true,     }
    client := http.Client{
        Transport: &transport,
    }

    respChan := make(chan *respData, 1)
    req, err := http.NewRequest("GET", "http://127.0.0.1:8000/", nil)
    if err != nil {
        fmt.Printf("new requestg failed, err:%v\n", err)
        return
    }
    req = req.WithContext(ctx) // 使用帶超時的ctx建立一個新的client request
    var wg sync.WaitGroup
    wg.Add(1)
    defer wg.Wait()
    go func() {
        resp, err := client.Do(req)
        fmt.Printf("client.do resp:%v, err:%v\n", resp, err)
        rd := &respData{
            resp: resp,
            err:  err,
        }
        respChan <- rd
        wg.Done()
    }()

    select {
    case <-ctx.Done():
        //transport.CancelRequest(req)
        fmt.Println("call api timeout")
    case result := <-respChan:
        fmt.Println("call server api success")
        if result.err != nil {
            fmt.Printf("call server api failed, err:%v\n", result.err)
            return
        }
        defer result.resp.Body.Close()
        data, _ := ioutil.ReadAll(result.resp.Body)
        fmt.Printf("resp:%v\n", string(data))
    }
}

func main() {
    // 定義一個100毫秒的超時
    ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
    defer cancel() // 調用cancel釋放子goroutine資源
    doCall(ctx)
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程