Go标准库Context

时间 2020-05-14

标签标准 context 繁體版

原文原文链接

Go标准库Context

在 Go http包的Server中，每个请求在都有一个对应的 goroutine 去处理。请求处理函数一般会启动额外的 goroutine 用来访问后端服务，好比数据库和RPC服务。用来处理一个请求的 goroutine 一般须要访问一些与请求特定的数据，好比终端用户的身份认证信息、验证相关的token、请求的截止时间。 当一个请求被取消或超时时，全部用来处理该请求的 goroutine 都应该迅速退出，而后系统才能释放这些 goroutine 占用的资源。html

总结一下：golang

上面哇啦哇啦一大堆，说白了，context就是用来简洁的管理goroutines的生命周期。数据库

为何须要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)//这里的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比较方便后端

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{}
}

Deadline方法须要返回当前Context被取消的时间，也就是完成工做的截止时间（deadline）；
Done 使用<-chan struct{}来通知退出，供被调用的goroutine监听。
Err方法会返回当前Context结束的缘由，它只会在Done返回的Channel被关闭时才会返回非空的值；
- 若是当前Context被取消就会返回Canceled错误；
- 若是当前Context超时就会返回DeadlineExceeded错误；
Value方法会从Context中返回键对应的值，对于同一个上下文来讲，屡次调用Value 并传入相同的Key会返回相同的结果，该方法仅用于传递跨API和进程间跟请求域的数据；

Background()和TODO()

Go内置两个函数：Background()和TODO()，这两个函数分别返回一个实现了Context接口的background和todo。咱们代码中最开始都是以这两个内置的上下文对象做为最顶层的partent context，衍生出更多的子上下文对象。网络

Background()主要用于main函数、初始化以及测试代码中，做为Context这个树结构的最顶层的Context，也就是根Context。ide

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。

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

	// 尽管ctx会过时，但在任何状况下调用它的cancel函数都是很好的实践。
	// 若是不这样作，可能会使上下文及其父类存活的时间超过必要的时间。
    
    //这个函数至关于为context的撤销提供了两个限制，一是主动调用cancel，另外一个就是到达deadlines
	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)
}

理解GO CONTEXT机制

1 什么是Context

最近在公司分析gRPC源码，proto文件生成的代码，接口函数第一个参数统一是ctx context.Context接口，公司很多同事都不了解这样设计的出发点是什么，其实我也不了解其背后的原理。今天趁着妮妲台风妹子正面登录深圳，全市停工、停课、停业，在家休息找了一些资料研究把玩一把。

Context一般被译做上下文，它是一个比较抽象的概念。在公司技术讨论时也常常会提到上下文。通常理解为程序单元的一个运行状态、现场、快照，而翻译中上下又很好地诠释了其本质，上下上下则是存在上下层的传递，上会把内容传递给下。在Go语言中，程序单元也就指的是Goroutine。

每一个Goroutine在执行以前，都要先知道程序当前的执行状态，一般将这些执行状态封装在一个Context变量中，传递给要执行的Goroutine中。上下文则几乎已经成为传递与请求同生存周期变量的标准方法。在网络编程下，当接收到一个网络请求Request，处理Request时，咱们可能须要开启不一样的Goroutine来获取数据与逻辑处理，即一个请求Request，会在多个Goroutine中处理。而这些Goroutine可能须要共享Request的一些信息；同时当Request被取消或者超时的时候，全部从这个Request建立的全部Goroutine也应该被结束。

2 context包

Go的设计者早考虑多个Goroutine共享数据，以及多Goroutine管理机制。Context介绍请参考Go Concurrency Patterns: Context，golang.org/x/net/context包就是这种机制的实现。

context包不只实现了在程序单元之间共享状态变量的方法，同时能经过简单的方法，使咱们在被调用程序单元的外部，经过设置ctx变量值，将过时或撤销这些信号传递给被调用的程序单元。在网络编程中，若存在A调用B的API, B再调用C的API，若A调用B取消，那也要取消B调用C，经过在A,B,C的API调用之间传递Context，以及判断其状态，就能解决此问题，这是为何gRPC的接口中带上ctx context.Context参数的缘由之一。

Go1.7(当前是RC2版本)已将原来的golang.org/x/net/context包挪入了标准库中，放在$GOROOT/src/context下面。标准库中net、net/http、os/exec都用到了context。同时为了考虑兼容，在原golang.org/x/net/context包下存在两个文件，go17.go是调用标准库的context包，而pre_go17.go则是以前的默认实现，其介绍请参考go程序包源码解读。

context包的核心就是Context接口，其定义以下：

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

Deadline会返回一个超时时间，Goroutine得到了超时时间后，例如能够对某些io操做设定超时时间。
Done方法返回一个信道（channel），当Context被撤销或过时时，该信道是关闭的，即它是一个表示Context是否已关闭的信号。
当Done信道关闭后，Err方法代表Context被撤的缘由。
Value可让Goroutine共享一些数据，固然得到数据是协程安全的。但使用这些数据的时候要注意同步，好比返回了一个map，而这个map的读写则要加锁。

Context接口没有提供方法来设置其值和过时时间，也没有提供方法直接将其自身撤销。也就是说，Context不能改变和撤销其自身。那么该怎么经过Context传递改变后的状态呢？

3 context使用

不管是Goroutine，他们的建立和调用关系老是像层层调用进行的，就像人的辈分同样，而更靠顶部的Goroutine应有办法主动关闭其下属的Goroutine的执行（否则程序可能就失控了）。为了实现这种关系，Context结构也应该像一棵树，叶子节点须老是由根节点衍生出来的。

要建立Context树，第一步就是要获得根节点，context.Background函数的返回值就是根节点：

func Background() Context

该函数返回空的Context，该Context通常由接收请求的第一个Goroutine建立，是与进入请求对应的Context根节点，它不能被取消、没有值、也没有过时时间。它经常做为处理Request的顶层context存在。

有了根节点，又该怎么建立其它的子节点，孙节点呢？context包为咱们提供了多个函数来建立他们：

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 interface{}, val interface{}) Context

函数都接收一个Context类型的参数parent，并返回一个Context类型的值，这样就层层建立出不一样的节点。子节点是从复制父节点获得的，而且根据接收参数设定子节点的一些状态值，接着就能够将子节点传递给下层的Goroutine了。

再回到以前的问题：该怎么经过Context传递改变后的状态呢？使用Context的Goroutine没法取消某个操做，其实这也是符合常理的，由于这些Goroutine是被某个父Goroutine建立的，而理应只有父Goroutine能够取消操做。在父Goroutine中能够经过WithCancel方法得到一个cancel方法，从而得到cancel的权利。

第一个WithCancel函数，它是将父节点复制到子节点，而且还返回一个额外的CancelFunc函数类型变量，该函数类型的定义为：

type CancelFunc func()

调用CancelFunc对象将撤销对应的Context对象，这就是主动撤销Context的方法。在父节点的Context所对应的环境中，经过WithCancel函数不只可建立子节点的Context，同时也得到了该节点Context的控制权，一旦执行该函数，则该节点Context就结束了，则子节点须要相似以下代码来判断是否已结束，并退出该Goroutine：

select {
    case <-cxt.Done():
        // do some clean...
}

WithDeadline函数的做用也差很少，它返回的Context类型值一样是parent的副本，但其过时时间由deadline和parent的过时时间共同决定。当parent的过时时间早于传入的deadline时间时，返回的过时时间应与parent相同。父节点过时时，其全部的子孙节点必须同时关闭；反之，返回的父节点的过时时间则为deadline。

WithTimeout函数与WithDeadline相似，只不过它传入的是从如今开始Context剩余的生命时长。他们都一样也都返回了所建立的子Context的控制权，一个CancelFunc类型的函数变量。

当顶层的Request请求函数结束后，咱们就能够cancel掉某个context，从而层层Goroutine根据判断cxt.Done()来结束。

WithValue函数，它返回parent的一个副本，调用该副本的Value(key)方法将获得val。这样咱们不光将根节点原有的值保留了，还在子孙节点中加入了新的值，注意若存在Key相同，则会被覆盖。

3.1 小结

context包经过构建树型关系的Context，来达到上一层Goroutine能对传递给下一层Goroutine的控制。对于处理一个Request请求操做，须要采用context来层层控制Goroutine，以及传递一些变量来共享。

Context对象的生存周期通常仅为一个请求的处理周期。即针对一个请求建立一个Context变量（它为Context树结构的根）；在请求处理结束后，撤销此ctx变量，释放资源。
每次建立一个Goroutine，要么将原有的Context传递给Goroutine，要么建立一个子Context并传递给Goroutine。
Context能灵活地存储不一样类型、不一样数目的值，而且使多个Goroutine安全地读写其中的值。
当经过父Context对象建立子Context对象时，可同时得到子Context的一个撤销函数，这样父Context对象的建立环境就得到了对子Context将要被传递到的Goroutine的撤销权。
4 使用原则

Programs that use Contexts should follow these rules to keep interfaces consistent across packages and enable static analysis tools to check context propagation:
使用Context的程序包须要遵循以下的原则来知足接口的一致性以及便于静态分析。
- Do not store Contexts inside a struct type; instead, pass a Context explicitly to each function that needs it. The Context should be the first parameter, typically named ctx；不要把Context存在一个结构体当中，显式地传入函数。Context变量须要做为第一个参数使用，通常命名为ctx；
- Do not pass a nil Context, even if a function permits it. Pass context.TODO if you are unsure about which Context to use；即便方法容许，也不要传入一个nil的Context，若是你不肯定你要用什么Context的时候传一个context.TODO；
- Use context Values only for request-scoped data that transits processes and APIs, not for passing optional parameters to functions；使用context的Value相关方法只应该用于在程序和接口中传递的和请求相关的元数据，不要用它来传递一些可选的参数；
- The same Context may be passed to functions running in different goroutines; Contexts are safe for simultaneous use by multiple goroutines；一样的Context能够用来传递到不一样的goroutine中，Context在多个goroutine中是安全的；
在子Context被传递到的goroutine中，应该对该子Context的Done信道（channel）进行监控，一旦该信道被关闭（即上层运行环境撤销了本goroutine的执行），应主动终止对当前请求信息的处理，释放资源并返回。

这篇博客分别转载自两个大佬的文章：
李文周的博客

这篇偏重于实战。

http://www.javashuo.com/article/p-ezaxcrps-do.html

这一篇偏重于逻辑分析。

受益不浅！

Go标准库Context

Go标准库Context

为何须要Context

基本示例

全局变量方式

通道方式

官方版的方案

Context初识

Context接口

Background()和TODO()

With系列函数

WithCancel

WithDeadline

WithTimeout

WithValue

使用Context的注意事项

客户端超时取消示例

server端

client端

理解GO CONTEXT机制

1 什么是Context

2 context包

3 context使用

3.1 小结

4 使用原则