context讲解

context包

context包介绍

​ 在go语言中，每个独立调用一般都会被单独的协程处理。但在处理一个请求时，往往可能需要在多个协程之间进行信息传递，甚至包括一层层地递进顺序传递，而且这种信息往往具有一定的场景状态。如一个请求可能衍生出各个协程之间需要满足一定的约束关系，如登录状态，前一个协程的计算结果、传递请求全局变量等功能

​ go语言为开发人员提供了一个解决方案，即标准的context包，有的地方也称为上下文。使用上下文可以在多个协程之间传递请求相关的数据、主动取消上下文或按照时间自动取消上下文等。

​ 每个协程在执行之前，一般都需要了解当前的执行状态，通常会将这些状态包装在上下文变量中进行传递。上下文几乎已经成为传递与Request同生命周期的变量的标准方法。

​ 当程序接收到一个网络请求的Request，在处理Request时，可能需要开启不同的协程来获取数据与逻辑处理，即一个请求Request，可能需要在多个协程中被处理。这些协程需要共享Request的一些信息，同时当顶层Context被取消或者超时的时候，所有从这个顶层Request创建的Context也应该结束。这些都可以通过Context来实现，Context就像是Request中的全局变量能让大家共享数据，当然实际上它是需要创建并传递的。

​ context包实现了在程序协程之间共享状态变量的方法，在被调用程序单元的外部，通过设置上下文变量ctx，将过期或取消信号传递给被调用的程序单元。

​ Context包中定义的Context结构如下所示：

//Context包包含过期、取消信号、request值传递等，方法在多个协程中线程安全
type Context interface {
    // Done方法在context被取消或者超时返回一个close的channel
    Done() <-chan struct{}
    Err() error
    
    //Deadline返回context超时时间
    Deadline()(deadline time.Time, ok bool)
    //Value返回context相关key对应的值
    Value(key interface{}) interface{}
}

• Deadline会返回一个超时时间，超时后Context无效
• Done方法返回一个通道(channel)，当Context被取消或过期时，该通道关闭，即它是一个表示是否已关闭的信号
• 当Done通道关闭后，Err方法表明Context被取消的原因
• Value是可以共享的数据

​ Context的创建和调用关系总是层层递进的，就像社会组织的层级一样，Context创建者的协程可以主动关闭其下层的Context的执行。为了实现这种关系，Context结构就像一颗树，叶子节点总是由根节点衍生出来的。

​ 要创建上下文树，第一步就是要得到根节点，context.Background函数的返回值就是根节点：

func Background() Context

​ Background()函数返回空的上下文，该上下文一般由接收请求的第一个协程创建，作为进入请求对应的上下文根节点，它不能被取消，没有值，也没有过期时间。它常常作为处理Requests的顶层上下文存在。

​ 有了根节点，又该怎么创建其他的子节点、孙节点呢？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类型的值，这样就层层创建出不同的节点。父节点创建Context，并传递给子节点。

​ 怎么通过Context传递改变的状态呢？使用Context的协程是无法取消某个操作的，只有父协程可以取消操作。在父协程中可以通过WithCancel函数获得一个CancelFunc函数类型变量，从而可以手工取消这个Context。

​ WithCancel函数将父节点Context复制到子节点，并且返回一个额外的CancelFunc函数类型变量，该函数类型的定义为：

type CancelFunc func()

​ 调用CancelFunc对象cancel将取消对应的Context对象，这就是主动取消Context的方法。在父节点的Context所对应的环境中，通过WithCancel函数不仅可以创建节点的Context，同时也获得了该节点Context的控制权，一旦执行该函数取消，该节点Context就结束了，而子节点则需要根据context.Done()来判断是否结束。例如：

select{
    case <-ctx.Done():
}

​ WithDeadline函数的作用也差不多，它返回的Context类型值同样是parent的副本，但其过期时间由deadline和parent的过期时间共同决定。这是因为父节点过期时，其所有的子孙节点必须同时关闭；反之，返回的父节点的过期时间则为deadline.

​ WithTimeout函数与WithDeadline类似，不过它传入的是上下文从现在开始剩余的生命时长。它们同样也都返回了所创建的上下文的控制权及一个CancelFunc类型的函数变量。

​ 当顶层的Request请求函数结束后，就可以取消某个上下文，从而再对应协程中根据ctx.Done()来决定是否结束协程本身。

​ WithValue函数返回parent的一个副本，调用该副本的Value(key)方法将得到对应的key的值。不光可以将根节点原有的值保留，还可以在子孙节点中加入新的值，注意若存在新、旧Key相同的情况，则旧key的值会被覆盖。

​ Context对象的生存周期一般仅为一个请求的处理周期，即针对一个请求创建一个Context变量（它是上下文树结构的根）。在请求处理结束后，撤销此变量，释放资源。

​ 每次创建一个协程时，可以将原有的上下文传递给这个子协程，或者新创建一个子上下文传递给这个协程。

​ 上下文能灵活地存储不同类型，不同数目的值，并且使多个协程安全的读写其中的值。

​ 当通过父Context对象创建子上下文对象时，即可获得子上下文的一个取消函数，这样父上下文对象的创建环境就获得了对子上下文的撤销权。

使用上下文时需遵循以下规则。
（1）上下文变量需要作为第一个参数使用，一般命名为ctx
（2）不要传入一个nil的上下文，不确定Context时可传一个context.TODO
（3）使用上下文的Value相关方法只传递请求相关的元数据，不要传递可选参数。
（4）同样的上下文可以用来传递到不同的协程中，上下文在多个协程中是安全的。

​ 在子上下文被传递到的协程中，应该对该子上下文的Done通道(channel)进行监控，一旦该通道被关闭(即上层运行环境撤销了本协程的执行)，应主动终止对当前请求信息的处理，释放资源并返回。

使用context同步信号

我们可以通过一个代码片段了解context.Context是如何对信号进行同步的。在这段代码中，我们创建了一个过期时间为1s的上下文，并向上下文传入handle函数，
该方法会使用500ms的时间处理传入的请求：

func main(){
  ctx, cancel := context.WithTimeout(context.Background(), 1 * time.Second)
  defer cancel()

  go handle(ctx, 500 * time.Millisecond)
  select {
  case <-ctx.Done():
    fmt.Println("main", ctx.Err())
  }
}

func handle(ctx context.Context, duration time.Duration){
  select {
  case <-ctx.Done():
    fmt.Println("handle", ctx.Err())
  case <-time.After(duration):
    fmt.Println("process request with", duration)
  }
}

因为过期时间大于处理时间，所以我们有足够的时间处理该请求

process request with 500ms
main context deadline exceeded

handle函数没有进入超时的select分支，但是main函数的select却会等待context.Context超时并打印出main context deadline exceeded
如果我们将处理请求时间增加至1500ms，整个程序都会因为上下文过期而被终止：

main context deadline exceeded
handle context deadline exceeded

默认上下文

context包中最常用的方法还是context.Background、context.TODO,这两个方法都会返回预先初始化好的私有变量background和todo，它们
会在同一个go程序中被复用：

func Background() Context{
  return background
}
func TODO() Context{
  return todo
}

这两个私有变量都是通过new(emptyCtx)语句初始化的，它们是指向私有结构体context.emptyCtx的指针，这是最简单、最常用的上下文类型:

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.emptyCtx 通过空方法实现了 context.Context 接口中的所有方法，它没有任何功能。

context层级关系

从源码来看，context.Background和context.TODO也只是互为别名，没有太大的差别，只是在使用和语义上稍有不同：

• context.Background是上下文的默认值，所有其他的上下文都应该从它衍生出来
• context.TODO应该仅在不确定应该使用哪种上下文时使用;
  在多数情况下，如果当前函数没有上下文作为入参，我们都会使用context.Background作为起始的上下文向下传递

上下文应用

​ 前面介绍协程时，对协程的管理和控制并没有进行讨论，目前已经清楚认识了通道、上下文以及sync包，通过这三者，完全可以达到完美控制协程运行和目的。

​ 通过go关键字很容易就能启动一个协程，但很好的管理和控制他们的运行却比较难。因此可以根据场景使用以下几种方法。

​ （1）使用sync.WaitGroup，它用于线程总同步，会等待一组线程集合完成，才会继续向下执行，这对监控所有子协程全部完成的情况特别有用，但要控制某个协程就无能为力了。

​ （2）使用通道来传递消息，一个协程发送通道信号，另一个协程通过select得到通道消息，这种方式可以满足协程之间的通信，控制协程运行。但如果协程数量达到一定程度，就很难把控了。或者这两个协程还和其他协程也有类似通信，例如A与B，B与C，如果A发信号B退出了，C有可能等不到B的通道信号而被遗忘。

​ （3）使用上下文来传递消息，上下文是层层传递机制，根节点完全控制了子节点，根节点(父节点)可以根据需要选择自动还是手动结束子节点。而每层节点所在的协程就可以根据信息来决定下一步的操作。

​ 下面来看看这怎么使用上下文控制协程的运行

​ 这里用上下文同时控制两个协程，这两个协程都可以收到cancel()发出的信号，甚至doNothing不结束协程可反复接收取消消息。

package main

import (
	"context"
	"log"
	"os"
	"time"
)

var logs *log.Logger

func doClean(ctx context.Context) {
	//for 循环每一秒检查一下，判断ctx是否被取消了，如果是就退出
	for {
		time.Sleep(time.Second * 1)
		select {
		case <-ctx.Done():
			log.Println("doClean接收到Cancel，做好收尾工作后马上退出.")
			return
		default:
			log.Println("doClean每隔一秒观察信号，继续观察...")
		}
	}
}

func doNothing(ctx context.Context) {
	for {
		time.Sleep(time.Second * 3)
		select {
		case <-ctx.Done():
			log.Println("doNothing收到Cancel，但不退出.....")
			// 退出协程，没有return的话ctx.Done()信号是可以一直接收到的
			// return
		default:
			log.Println("doNothing每隔3秒观察信号，一直运行")
		}
	}
}

func main() {
	logs = log.New(os.Stdout, "", log.Ltime)
	//创建一个ctx
	ctx, cancel := context.WithCancel(context.Background())
	//传递ctx
	go doClean(ctx)
	go doNothing(ctx)

	//主程序阻塞20秒，留给协程来演示
	time.Sleep(20 * time.Second)
	log.Println("cancel")

	//调用cancel: context.WithCancel返回的CancelFunc
	cancel()

	// 发出cancel命令后，主程序阻塞10秒，在看协程的运行情况
	time.Sleep(10 * time.Second)
}

打印结果

2022/04/14 11:12:24 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:25 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:26 doNothing每隔3秒观察信号，一直运行
2022/04/14 11:12:26 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:27 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:28 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:29 doNothing每隔3秒观察信号，一直运行
2022/04/14 11:12:29 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:30 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:31 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:32 doNothing每隔3秒观察信号，一直运行
2022/04/14 11:12:32 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:33 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:34 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:35 doNothing每隔3秒观察信号，一直运行
2022/04/14 11:12:35 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:36 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:37 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:38 doNothing每隔3秒观察信号，一直运行
2022/04/14 11:12:38 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:39 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:40 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:41 doNothing每隔3秒观察信号，一直运行
2022/04/14 11:12:41 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:42 doClean每隔一秒观察信号，继续观察...
2022/04/14 11:12:43 cancel
2022/04/14 11:12:43 doClean接收到Cancel，做好收尾工作后马上退出.
2022/04/14 11:12:44 doNothing收到Cancel，但不退出.....
2022/04/14 11:12:47 doNothing收到Cancel，但不退出.....
2022/04/14 11:12:50 doNothing收到Cancel，但不退出.....

下面代码用上下文嵌套控制3个协程A，B，C。在主程序发出cancel信号后，每个协程都能接收根上下文的Done()信号而退出。

package main

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

func A(ctx context.Context) int {
	ctx = context.WithValue(ctx, "AFunction", "Great")

	go B(ctx)
	select {
	//监测自己上层的ctx
	case <-ctx.Done():
		fmt.Println("A Done")
		return -1
	}
	return 1
}

func B(ctx context.Context) int {
	fmt.Println("A value in B", ctx.Value("AFunction"))
	ctx = context.WithValue(ctx, "BFunction", 999)

	go C(ctx)

	select {
	//监测自己上层的ctx
	case <-ctx.Done():
		fmt.Println("B Done")
		return -2
	}
	return 2
}

func C(ctx context.Context) int {
	fmt.Println("B value in C", ctx.Value("AFunction"))
	fmt.Println("B value in C", ctx.Value("BFunction"))
	select {
	//结束时候做点什么
	case <-ctx.Done():
		fmt.Println("C Done")
		return -3
	}
	return 3
}

func main() {
	// 自动取消(定时取消)
	{
		timeout := 10 * time.Second
		ctx, _ := context.WithTimeout(context.Background(), timeout)
		fmt.Println("A执行完成，返回：", A(ctx))
		select {
		case <-ctx.Done():
			fmt.Println("context Done")
			break
		}
	}
	time.Sleep(20 * time.Second)
}

结果

A value in B Great
B value in C Great
B value in C 999
A Done
A执行完成，返回： -1
context Done
C Done
B Done

最后看下上下文在http中是怎么传递的

package main

import (
	"context"
	"net/http"
	"time"
)

// ContextMiddle是HTTP服务中间件，统一读取通行cookie并使用ctx传递

func ContextMiddle(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		cookie, _ := r.Cookie("Check")
		if cookie != nil {
			ctx := context.WithValue(r.Context(), "Check", cookie.Value)
			next.ServeHTTP(w, r.WithContext(ctx))
		} else {
			next.ServeHTTP(w, r)
		}
	})
}

// 强制设置通行cookie
func CheckHandler(w http.ResponseWriter, r *http.Request) {
	expitation := time.Now().Add(24 * time.Hour)
	cookie := http.Cookie{Name: "Check", Value: "42", Expires: expitation}
	http.SetCookie(w, &cookie)
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
	//通过取中间件传过来的context值来判断是否放行通过
	if chk := r.Context().Value("Check"); chk == "42" {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("Lets go!\n"))
	} else {
		w.WriteHeader(http.StatusNotFound)
		w.Write([]byte("No Pass!"))
	}
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/", indexHandler)

	// 人为设置通行cookie
	mux.HandleFunc("/chk", CheckHandler)

	ctxMux := ContextMiddle(mux)
	http.ListenAndServe(":8080", ctxMux)
}

打开浏览器访问http://localhost:8080/chk，然后访问http://localhost:8080/，由于cookie已经设置，会看到正常通行的结果，否则将会看到无法正常通行时的信息。Context信息的传递主要靠中间件ContextMiddle来进行。

取消信号

context.WithCancel函数能够从context.Context中衍生出一个新的子上下文并返回用于取消该上下文的函数。一旦我们执行返回的取消函数，
当前上下文以及它的子上下文都会被取消，所有的Goroutine都会同步收到这一取消信号。

Context子树的取消

我们直接从context.WithCancel函数的实现来看它到底做了什么：

func WithCancel(parent Context)(ctx Context, cancel CancelFunc){
  c := newCancelCtx(parent)
  propagateCancel(parent, &c)
  return &c, func(){c.cancel(true, Canceled)}
}

• context.newCancelCtx将传入的上下文包装成私有结构体context.cancelCtx
• context.propagateCancel会构建父子上下文之间的关联，当父上下文被取消时，子上下文也会被取消：

func propagateCancel(parent Context, child canceler){
  done := parent.Done()
  if done == nil{
    return // 父上下文不会触发取消信号
  }
  select{
  case <-done:
    child.cancel(false, parent.Err()) // 父上下文已经被取消
    return
  default:
  }

  if p, ok := parentCancelCtx(parent);ok{
    p.mu.Lock()
    if p.err != nil{
      child.cancel(false, p.err)
    }else{
      p.children[child] = struct{}{}
    }
    p.mu.Unlock()
  }else{
    go func(){
      select {
      case <-parent.Done():
        child.cancel(false, parent.Err())
      case <-child.Done()
      }
    }()
  }
}

上述函数总共与父上下文相关的三种不同的情况

1. 当parent.Done()==nil，也就是parent不会触发取消事件时，当前函数会直接返回；
2. 当child的继承链包含可以取消的上下文时，会判断parent是否已经触发了取消信号；

• 如果已经被取消，child会立刻被取消
• 如果没有被取消，child会被加入parent的children列表中，等待parent释放取消信号
  3.当父上下文是开发者自定义的类型，实现了context.Context接口并在Done()方法中返回了非空的管道时
• 运行一个新的Goroutine同时监听parent.Done()和child.Done()两个Channel;
• 在parent.Done()关闭时调用child.cancel取消子上下文
  context.propagateCancel的作用在parent和child之间同步取消和结束的信号，保证在parent被取消时，
  child也会收到对应的信号，不会出现状态不一致的情况
  context.cancelCtx实现的几个接口方法也没有太多值的分析的地方，该结构体最重要的方法是context.cancelCtx.cancel
  该方法会关闭上下文中的Channel并向所有子上下文同步取消信号：

func (c *cancelCtx)cancel(removeFromParent bool, err error){
  c.mu.Lock()
  if c.err != nil{
    c.mu.Unlock()
    return
  }
  c.err = err
  if c.done == nil{
    c.done == closedchan
  }else{
    close(c.done)
  }
  for child := range c.children{
    child.cancel(false, err)
  }
  c.children = nil
  c.mu.Unlock()
  if removeFromParent{
    removeChild(c.Context, c)
  }
}

除了context.WithCancel之外，context包中的另外两个函数context.WithDeadline和
context.WithTimeout也都能创建可以被取消的计时器上下文context.timeCtx

func WithTimeout(parent Context, timeout time.Duration)(Context, CancelFunc){
  return WithDeadline(parent, time.Now().Add(timeout))
}

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc){
  if cur, ok := parent.Deadline(); ok && cur.Before(d){
    return WithCancel(parent)
  }
  c := &timeCtx{
    cancelCtx: newCancelCtx(parent),
    deadline: d,
  }
  propagateCancel(parent, c)
  dur := time.Until(d)
  if dur <= 0{
    c.cancel(true, DeadlineExceeded) // 已经过了截止日期
    return c, func(){c.cancel(false, Canceled)}
  }
  c.mu.Lock()
  defer c.mu.Unlock()
  if c.err == nil{
    c.timer = time.AfterFunc(dur, func(){
      c.cancel(true, DeadlineExceeded)
    })
  }
  return c, func(){c.cancel(true, Canceled)}
}

context.WithDeadline在创建context.timerCtx的过程中判断了父上下文的截止日期与当前日期，并通过time.AfterFunc
创建定时器，当时间超过了截止日期后会调用context.timeCtx.cancel同步取消信号
context.timerCtx内部不仅通过嵌入context.cancelCtx结构体继承了相关的变量和方法，还通过持有的定时器timer和截止时间
deadline实现了定时取消的功能：

type timerCtx struct{
  cancelCtx
  timer *time.Timer

  deadline time.Time
}

func (c *timerCtx)Deadline() (deadline time.Time, ok bool){
  return c.deadline, true
}

func (c *timerCtx) cancel(removeFromParent bool, err error){
  c.cancelCtx.cancel(false, err)
  if removeFromParent{
    removeChild(c.cancelCtx.Context, c)
  }
  c.mu.Lock()
  if c.timer != nil{
    c.timer.Stop()
    c.timer = nil
  }
  c.mu.Unlock()
}

context.timerCtx.cancel方法不仅调用了context.cancelCtx.cancel，还会停止持有的定时器减少不必要的资源浪费

传值方法

context包中的context.WithValue能从父上下文中创建一个子上下文，传值的上下文使用context.valueCtx类型：

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

context.valueCtx结构体会将除了Value之外的Err、Deadline等方法代理到父上下文中，它只会响应context.valueCtx.Value
方法，该方法的实现也很简单

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

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

如果context.valueCtx中存储的键值对与context.valueCtx.Value方法中传入的参数不匹配，就会从父上下文中查找该键值对应的
值直到某个父上下文中返回nil或者查找到对应的值