Go語言并發(fā)編程基礎上下文概念詳解

更新時間：2022年08月05日 15:47:14 作者：宇宙之一粟

這篇文章主要為大家介紹了Go語言并發(fā)編程基礎上下文示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪

前言

相信大家以前在做閱讀理解的時候，一定有從老師那里學一個技巧或者從參考答案看個：結合上下文。根據(jù)上下文我們能夠找到有助于解題的相關信息，也能更加了解段落的思想。

在開發(fā)過程中，也有這個上下文（Context）的概念，而且上下文也必不可少，缺少上下文，就不能獲取完整的程序信息。那么什么是程序中的上下文呢？

簡單來說，就是在 API 之間或者函數(shù)調(diào)用之間，除了業(yè)務參數(shù)信息之外的額外信息。比如，服務器接收到客戶端的 HTTP 請求之后，可以把客戶端的 IP 地址和端口、客戶端的身份信息、請求接收的時間、Trace ID 等信息放入到上下文中，這個上下文可以在后端的方法調(diào)用中傳遞。

1 Go 中的 Context

Golang 的上下文也是應用開發(fā)常用的并發(fā)控制工具。同理，上下文可以用于在程序中的 API 層或進程之間共享請求范圍的數(shù)據(jù)，除此之外，Go 的 Context 庫還提供取消信號（Cancel）以及超時機制（Timeout)。

Context 又被稱為上下文，與 WaitGroup 不同的是，Context 對于派生 goroutine 有更強的控制力，可以管理多級的 goroutine。

但我們在 Go 中創(chuàng)建一個 goroutine 時，如果發(fā)生了一個錯誤，并且這個錯誤永遠不會終止，而其他程序會繼續(xù)進行。加入有一個不被調(diào)用的 goroutine 運行無限循環(huán)，如下所示：

package main
import "fmt"
func main() {
    dataCom := []string{"alex", "kyrie", "kobe"}
    go func(data []string) {
        // 模擬大量運算的死循環(huán)
    }(dataCom)
    // 其他代碼正常執(zhí)行
    fmt.Println("剩下的代碼執(zhí)行正常邏輯")
}

上面的例子并不完整，dataCom goroutine 可能會也可能不會成功處理數(shù)據(jù)。它可能會進入無限循環(huán)或導致錯誤。我們的其余代碼將不知道發(fā)生了什么。

有多種方法可以解決這個問題。其中之一是使用通道向我們的主線程發(fā)送一個信號，表明這個 goroutine 花費的時間太長，應該取消它。

package main
import (
	"fmt"
	"time"
)
func main() {
	stopChannel := make(chan bool)
	dataCom := []string{"alex", "kyrie", "kobe"}
	go func(stopChannel chan bool) {
		go func(data []string) {
			// 大量的計算
		}(dataCom)
		for range time.After(2 * time.Second) {
			fmt.Println("此操作運行時間過長，取消中")
			stopChannel &lt;- true
		}
	}(stopChannel)
	&lt;-stopChannel
	// 其他代碼正常執(zhí)行
	fmt.Println("剩下的代碼執(zhí)行正常邏輯")
}

上面的邏輯很簡單。我們正在使用一個通道向我們的主線程發(fā)出這個 goroutine 花費的時間太長的信號。但是同樣的事情可以用 context 來完成，這正是 context 包存在的原因。

package main
import (
	"context"
	"fmt"
	"time"
)
func main() {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
	defer cancel()
	dataCom := []string{"alex", "kyrie", "kobe"}
	go func() {
		go func(data []string) {
			// 大量的計算
		}(dataCom)
		for range time.After(2 * time.Second) {
			fmt.Println("此操作運行時間過長，取消中")
			cancel()
			return
		}
	}()
	select {
	case <-ctx.Done():
		fmt.Println("上下文被取消")
	}
}

2 Context 接口

Context 接口定義：

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

Context 接口定義了 4 個方法：

Deadline()：返回取消此上下文的時間 deadline（如果有）。如果未設置 deadline 時，則返回 ok==false，此時 deadline 為一個初始值的 time.Time 值。后續(xù)每次調(diào)用這個對象的 Deadline 方法時，都會返回和第一次調(diào)用相同的結果。
Done() ：返回一個用于探測 Context 是否取消的 channel，當 Context 取消會自動將該 channel 關閉，如果該 Context 不能被永久取消，該函數(shù)返回 nil。例如 context.Background()；如果 Done 被 close，Err 方法會返回 Done 被 close 的原因。
Err(): 該方法會返回 context 被關閉的原因，關閉原因由 context 實現(xiàn)控制，不需要用戶設置；如果 Done() 尚未關閉，則 Err() 返回 nil
Value() : 在樹狀分布的 goroutine 之間共享數(shù)據(jù)，用 map 鍵值的工作方法，通過 key 值查詢 value。

每次創(chuàng)建新上下文時，都會得到一個符合此接口的類型。上下文的真正實現(xiàn)隱藏在這個包和這個接口后面。這些是您可以創(chuàng)建的工廠類型的上下文：

context.TODO

context.Background

context.WithCancel

context.WithValue

context.WithTimeout

context.WithDeadline

3 Context Tree

在實際實現(xiàn)中，我們通常使用派生上下文。我們創(chuàng)建一個父上下文并將其傳遞到一個層，我們派生一個新的上下文，它添加一些額外的信息并將其再次傳遞到下一層，依此類推。通過這種方式，我們創(chuàng)建了一個從作為父級的根上下文開始的上下文樹。

這種結構的優(yōu)點是我們可以一次性控制所有上下文的取消。如果根信號關閉了上下文，它將在所有派生的上下文中傳播，這些上下文可用于終止所有進程，立即釋放所有內(nèi)容。這使得上下文成為并發(fā)編程中非常強大的工具。

4 創(chuàng)建上下文

4.1 上下文創(chuàng)建函數(shù)

我們可以從現(xiàn)有的上下文中創(chuàng)建或派生上下文。頂層（根）上下文是使用 Background 或 TODO 方法創(chuàng)建的，而派生上下文是使用 WithCancel、WithDeadline、WithTimeout 或 WithValue 方法創(chuàng)建的。

所有派生的上下文方法都返回一個取消函數(shù) CancelFunc，但 WithValue 除外，因為它與取消無關。調(diào)用 CancelFunc 會取消子項及其子項，刪除父項對子項的引用，并停止任何關聯(lián)的計時器。調(diào)用 CancelFunc 失敗會泄漏子項及其子項，直到父項被取消或計時器觸發(fā)。

context.Background() ctx Context

此函數(shù)返回一個空上下文。這通常只應在主請求處理程序或頂級請求處理程序中使用。這可用于為主函數(shù)、初始化、測試以及后續(xù)層或其他 goroutine 派生上下文的時候。

ctx, cancel := context.Background()

context.TODO() ctx Context

此函數(shù)返回一個非 nil 的、空的上下文。沒有任何值、不會被 cancel，不會超時，也沒有截止日期。但是，這也應該僅在您不確定要使用什么上下文或者該函數(shù)還不能用于接收上下文時，可以使用這個方法，并且將在將來需要添加時使用。

ctx, cancel := context.TODO()

context.WithValue(parent Context, key, val interface{}) Context

這個函數(shù)接受一個上下文并返回一個派生的上下文，其中值 val 與 key 相關聯(lián)，并與上下文一起經(jīng)過上下文樹。

WithValue 方法其實是創(chuàng)建了一個類型為 valueCtx 的上下文，它的類型定義如下：

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

這意味著一旦你得到一個帶有值的上下文，任何從它派生的上下文都會得到這個值。該值是不可變的，因此是線程安全的。

提供的鍵必須是可比較的，并且不應該是字符串類型或任何其他內(nèi)置類型，以避免使用上下文的包之間發(fā)生沖突。 WithValue 的用戶應該為鍵定義自己的類型。

為避免在分配給 interface{} 時進行分配，上下文鍵通常具有具體類型 struct{}?；蛘撸瑢С龅纳舷挛逆I變量的靜態(tài)類型應該是指針或接口。

package main
import (
  "context"
  "fmt"
)
type contextKey string
func main() {
  var authToken contextKey = "auth_token"
  ctx := context.WithValue(context.Background(), authToken, "Hello123456")
  fmt.Println(ctx.Value(authToken))
}

運行該代碼：

$ go run .
Hello123456

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

此函數(shù)接收父上下文并返回派生上下文，返回 parent 的副本，只是副本中的 Done Channel 是新建的對象，它的類型是 cancelCtx。在這個派生上下文中，添加了一個新的 Done channel，該 channel 在調(diào)用 cancel 函數(shù)或父上下文的 Done 通道關閉時關閉。

要記住的一件事是，我們永遠不應該在不同的函數(shù)或層之間傳遞這個 cancel ，因為它可能會導致意想不到的結果。創(chuàng)建派生上下文的函數(shù)應該只調(diào)用取消函數(shù)。

下面是一個使用 Done 通道演示 goroutine 泄漏的示例:

package main
import (
  "context"
  "fmt"
  "math/rand"
  "time"
)
func main() {
  rand.Seed(time.Now().UnixNano())
  ctx, cancel := context.WithCancel(context.Background())
  defer cancel()
  for char := range randomCharGenerator(ctx) {
    generatedChar := string(char)
    fmt.Printf("%v\n", generatedChar)
    if generatedChar == "o" {
      break
    }
  }
}
func randomCharGenerator(ctx context.Context) <-chan int {
  char := make(chan int)
  seedChar := int('a')
  go func() {
    for {
      select {
      case <-ctx.Done():
        fmt.Printf("found %v", seedChar)
        return
      case char <- seedChar:
        seedChar = 'a' + rand.Intn(26)
      }
    }
  }()
  return char
}

運行結果：

$ go run .
a
m
q
c
l
t
o

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)

此函數(shù)從其父級返回派生上下文，返回一個 parent 的副本。

當期限超過或調(diào)用取消函數(shù)時，該派生上下文將被取消。例如，您可以創(chuàng)建一個在未來某個時間自動取消的上下文，并將其傳遞給子函數(shù)。當該上下文由于截止日期用完而被取消時，所有獲得該上下文的函數(shù)都會收到通知停止工作并返回。如果 parent 的截止日期已經(jīng)早于 d，則上下文的 Done 通道已經(jīng)關閉。

下面是我們正在讀取一個大文件的示例，該文件的截止時間為當前時間 2 毫秒。我們將獲得 2 毫秒的輸出，然后將關閉上下文并退出程序。

package main
import (
    "bufio"
    "context"
    "fmt"
    "log"
    "os"
    "time"
)
func main() {
    // context with deadline after 2 millisecond
    ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(2*time.Millisecond))
    defer cancel()
    lineRead := make(chan string)
    var fileName = "sample-file.txt"
    file, err := os.Open(fileName)
    if err != nil {
        log.Fatalf("failed opening file: %s", err)
    }
    scanner := bufio.NewScanner(file)
    scanner.Split(bufio.ScanLines)
    // goroutine to read file line by line and passing to channel to print
    go func() {
        for scanner.Scan() {
            lineRead <- scanner.Text()
        }
        close(lineRead)
        file.Close()
    }()
outer:
    for {
        // printing file line by line until deadline is reached
        select {
        case <-ctx.Done():
            fmt.Println("process stopped. reason: ", ctx.Err())
            break outer
        case line := <-lineRead:
            fmt.Println(line)
        }
    }
}

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

這個函數(shù)類似于 context.WithDeadline。不同之處在于它將持續(xù)時間作為輸入而不是時間對象。此函數(shù)返回一個派生上下文，如果調(diào)用取消函數(shù)或超過超時持續(xù)時間，該上下文將被取消。

WithTimeout 的實現(xiàn)是：

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
    // 當前時間+timeout就是deadline
    return WithDeadline(parent, time.Now().Add(timeout))
}

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

package main
import (
    "bufio"
    "context"
    "fmt"
    "log"
    "os"
    "time"
)
func main() {
    // context with deadline after 2 millisecond
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Millisecond)
    defer cancel()
    lineRead := make(chan string)
    var fileName = "sample-file.txt"
    file, err := os.Open(fileName)
    if err != nil {
        log.Fatalf("failed opening file: %s", err)
    }
    scanner := bufio.NewScanner(file)
    scanner.Split(bufio.ScanLines)
    // goroutine to read file line by line and passing to channel to print
    go func() {
        for scanner.Scan() {
            lineRead <- scanner.Text()
        }
        close(lineRead)
        file.Close()
    }()
outer:
    for {
        // printing file line by line until deadline is reached
        select {
        case <-ctx.Done():
            fmt.Println("process stopped. reason: ", ctx.Err())
            break outer
        case line := <-lineRead:
            fmt.Println(line)
        }
    }
}

如果父上下文的 Done 通道關閉，它最終將關閉所有派生的 Done 通道（所有后代）,如：

package main
import (
    "context"
    "fmt"
    "time"
)
func main() {
    c := make(chan string)
    go func() {
        time.Sleep(1 * time.Second)
        c <- "one"
    }()
    ctx1 := context.Context(context.Background())
    ctx2, cancel2 := context.WithTimeout(ctx1, 2*time.Second)
    ctx3, cancel3 := context.WithTimeout(ctx2, 10*time.Second) // derives from ctx2
    ctx4, cancel4 := context.WithTimeout(ctx2, 3*time.Second)  // derives from ctx2
    ctx5, cancel5 := context.WithTimeout(ctx4, 5*time.Second)  // derives from ctx4
    cancel2()
    defer cancel3()
    defer cancel4()
    defer cancel5()
    select {
    case <-ctx3.Done():
        fmt.Println("ctx3 closed! error: ", ctx3.Err())
    case <-ctx4.Done():
        fmt.Println("ctx4 closed! error: ", ctx4.Err())
    case <-ctx5.Done():
        fmt.Println("ctx5 closed! error: ", ctx5.Err())
    case msg := <-c:
        fmt.Println("received", msg)
    }
}

在這里，由于我們在創(chuàng)建其他派生上下文后立即關閉 ctx2，因此所有其他上下文也會立即關閉，隨機打印 ctx3、ctx4 和 ctx5 關閉消息。 ctx5 是從 ctx4 派生的，由于 ctx2 關閉的級聯(lián)效應，它正在關閉。嘗試多次運行，您會看到不同的結果。

使用 Background 或 TODO 方法創(chuàng)建的上下文沒有取消、值或截止日期。

package main
import (
    "context"
    "fmt"
)
func main() {
    ctx := context.Background()
    _, ok := ctx.Deadline()
    if !ok {
        fmt.Println("no dealine is set")
    }
    done := ctx.Done()
    if done == nil {
        fmt.Println("channel is nil")
    }
}

4.2 Context 使用規(guī)范

不要將上下文存儲在結構類型中；相反，將 Context 顯式傳遞給需要它的每個函數(shù)。 Context 應該是第一個參數(shù)，通常命名為 ctx。

func DoSomething(ctx context.Context, arg Arg) error {
    // ... use ctx ...
}

不要傳遞 nil 上下文，即使函數(shù)允許。如果不確定要使用哪個 Context，請傳遞 context.TODO 或使用 context.Background() 創(chuàng)建一個空的上下文對象。
僅使用上下文傳遞請求范圍的數(shù)據(jù)。不要傳遞應該使用函數(shù)參數(shù)傳遞的數(shù)據(jù)。
始終尋找 goroutine 泄漏并有效地使用上下文來避免這種情況。
如果父上下文的 Done 通道關閉，它最終將關閉所有派生的 Done 通道（所有后代）
上下文只是臨時做函數(shù)之間的上下文傳透，不能持久化上下文
key 的類型不應該是字符串類型或者其它內(nèi)建類型，否則容易在包之間使用 Context 時候產(chǎn)生沖突。使用 WithValue 時，key 的類型應該是自己定義的類型。

4.3 Context 使用場景

上下文信息傳遞（request-scoped），比如處理 http 請求、在請求處理鏈路上傳遞信息；
控制子 goroutine 的運行；
超時控制的方法調(diào)用；
可以取消的方法調(diào)用。

5 總結

Context 是在 Go 中進行并發(fā)編程時最重要的工具之一。上下文的主要作用是在多個 Goroutine 或者模塊之間同步取消信號或者截止日期，用于減少對資源的消耗和長時間占用，避免資源浪費。標準庫中的 database/sql、os/exec、net、net/http 等包中都使用到了 Context。

參考鏈接：

Go Concurrency Patterns: Context

Simplifying context in Go

以上就是Go語言并發(fā)編程基礎上下文概念詳解的詳細內(nèi)容，更多關于Go語言并發(fā)上下文的資料請關注腳本之家其它相關文章！

您可能感興趣的文章:

Go 切片導致內(nèi)存泄露的幾種原因
某些情況下，對一個已存在的切片或數(shù)組進行切分操作可能會導致內(nèi)存泄漏，本文主要介紹了Go 切片導致內(nèi)存泄露的幾種原因，感興趣的可以了解一下
2023-05-05
GO中?分組聲明與array,?slice,?map函數(shù)
這篇文章主要介紹了GO中?分組聲明與array,slice,map函數(shù)，Go語言中，同時聲明多個常量、變量，或者導入多個包時，可采用分組的方式進行聲明，下面詳細介紹需要的小伙伴可以參考一下
2022-03-03
gtoken替換jwt實現(xiàn)sso登錄的問題小結
這篇文章主要介紹了gtoken替換jwt實現(xiàn)sso登錄,主要介紹了替換jwt的原因分析及gtoken的優(yōu)勢，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下
2022-05-05
詳解Go語言中調(diào)度器的原理與使用
這篇文章主要介紹了Go語言運行時調(diào)度器的實現(xiàn)原理，其中包含調(diào)度器的設計與實現(xiàn)原理、演變過程以及與運行時調(diào)度相關的數(shù)據(jù)結構，希望對大家有所幫助
2023-07-07
從零封裝Gin框架實現(xiàn)數(shù)據(jù)庫初始化GORM
這篇文章主要為大家介紹了從零封裝Gin框架實現(xiàn)數(shù)據(jù)庫初始化GORM,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
2024-01-01
Go 面向包新提案透明文件夾必要性分析
這篇文章主要為大家介紹了Go 面向包新提案,透明文件夾必要性分析,看看是否合適加進 Go 特性中,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
2023-11-11
Go語言實現(xiàn)將中文轉化為拼音功能
這篇文章主要為大家詳細介紹了Go語言中如何實現(xiàn)將中文轉化為拼音功能,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下
2025-01-01
go語言中的Stringer的使用示例詳解
Go 語言中的 Stringer 是一個非常有用的接口,它在標準庫的 fmt 包中定義,Stringer 接口允許類型定義它們的字符串表示方式,這在格式化輸出時特別有用,這篇文章主要介紹了go語言中的Stringer的使用,需要的朋友可以參考下
2025-02-02
Go語言基礎結構體用法及示例詳解
這篇文章主要為大家介紹了Go語言基礎結構體的用法及示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步
2021-11-11
go日志庫logrus的安裝及快速使用
這篇文章主要為大家介紹了go日志庫logrus的安裝及快速使用示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
2022-08-08