理解Context机制

Love The Way You Lie 2022-09-03 09:29 255阅读 0赞

![4ec2a02cf961b7af57aca0bcb4d95735.png][]

**小菜刀的疑问**：记得最开始看TiDB源码时，发现它的代码中很多函数都带有一个参数ctx context.Context接口，而且它会层层传递，这让当时的我十分迷惑，这个ctx到底是干嘛的。

![5a9af65f001bda4f62b8da593a6255e4.gif][]

**什么是Context**

**context从字面解释是“语境”，也被称作“上下文”。听起来有点抽象，一般理解为程序单元的一个运行状态、现场、快照。其中上下是指存在上下层的传递，上会把内容传递给下，程序单元则指的是 Goroutine。注意，这种上下或者父子只是一种逻辑上的概念，在Go中，所有Goroutine都是平等的。**

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

![0637fc6f75c5890feb4179d7fed32dae.gif][]

**为什么需要Context**

在网络编程中，若存在处理Request的A调用B的API, B再调用C的API（A、B、C代表不同的Goroutine）。当某一时刻请求A的服务被取消或者超时，那么A应该退出，B、C也应该被立即退出，这样系统才可回收A、B、C所占用的资源。

![9eda57d55ef6572dce3576f16f772aa9.png][]

即一个request的处理通常贯穿多个goroutine，这些goroutine之间存在交互。那么，如何有效管理这些goroutine成为一个问题（主要是退出通知和元数据传递）。

Go的解决方法是Context机制，相互调用的goroutine之间通过传递context变量保持关联，这样在不用暴露各goroutine内部实现细节的前提下，有效地控制各goroutine的运行.

![82b8540968b8cb64202f3134d0c4b325.png][]

![1a2ca2fadaed301855df56f226df57e6.gif][]

**如何使用Context**

Context是golang官方定义的一个package，它是在 Go 1.7 之后加入到Go语言标准库中,在此之前位于golang.org/x/net/context库中。该库定义了Context接口类型，其中包含了Deadline/Done/Err方法以及绑定到Context上的成员变量值Value，具体如下。

type Context interface {
        // 返回Context的超时时间（超时返回场景）
        Deadline() (deadline time.Time, ok bool)
    
    
        // 在Context超时或取消时（即结束了）返回一个关闭的channel
        // 即如果当前Context超时或取消时，Done方法会返回一个channel，然后其他地方就可以通过判断Done方法是否有返回（channel），如果有则说明Context已结束
        // 故其可以作为广播通知其他相关方本Context已结束，请做相关处理.
        Done() <-chan struct{}
    
    
        // 返回Context取消的原因
        Err() error
    
    
        // 返回Context相关数据，通常是传递元数据
        Value(key interface{}) interface{}
    }

**(左右滑动查看完整代码图片)**

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

在多个Goroutine中，他们的逻辑关系总是层层调用进行的，就像人的辈分一样，而更靠顶部的Goroutine应有办法主动关闭其下属的Goroutine的执行（不然程序可能就失控了）。为了实现这种关系，Goroutine之间Context对象的传递结构，也应该像一棵树，叶子节点须总是由根节点衍生出来的。

![213c9b6b5c35c5b4c907734de3cb6f4f.png][]

上图示例中，pc是父Context，cc是子Context。从Goroutine G1处将cc传递至G2-G8，它们呈现的是一种树形传递关系。

**1. 创建根节点**

要创建Context树，首先就是要创建根节点。而要创建根节点Context，必须创建对象实现了Context接口方法，值得开心的是，Context 接口并不需要我们实现，Go 内置已经帮我们实现了 2 个，我们代码中最开始都是以这两个内置的作为最顶层的父级 Context，衍生出更多的子级 Context。

var (
      background = new(emptyCtx)
      todo       = new(emptyCtx)
    )
    
    
    // 返回一个空的Context，它作为所有由此继承Context的根节点
    func Background() Context {
      return background
    }
    
    
    // 返回一个空的Context，它作为所有由此继承Context的根节点
    func TODO() Context {
      return todo
    }

**(左右滑动查看完整代码图片)**

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

一个是 TODO，当我们不知道该使用什么 Context 的时候，可以使用这个。

它们两个本质上都是 emptyCtx 结构体类型，是一个不可取消，没有设置截止时间，没有携带任何值的 Context。

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
    }

**(左右滑动查看完整代码图片)**

从 emptyCtx 实现 Context 接口的方法可以看到，方法体都为空，返回的都是空值。

**2. 衍生子节点**

有了根节点之后，接下来就是衍生子孙节点。

为了可以很好的控制子孙节点，Context包提供的创建方法带有第二返回值（CancelFunc类型），它相当于一个Hook，在子goroutine执行过程中，可以通过触发Hook来达到控制子goroutine的目的（通常是取消，即让其停下来）。

*  WithCancel 函数，传递一个父 Context 作为参数，返回子 Context，以及一个取消函数用来取消 Context。 
 *  WithDeadline 函数，它会多传递一个截止时间参数，意味着到了这个时间点，会自动取消 Context，当然我们也可以不等到这个时候，可以提前通过取消函数进行取消。
 *  WithTimeout 和 WithDeadline 基本上一样，这个表示是超时自动取消，是多少时间后自动取消 Context 的意思。
 *  WithValue 函数和取消 Context 无关，它是为了生成一个绑定了一个键值对数据的 Context，这个绑定的数据可以通过 Context.Value 方法访问到。

// 带cancel返回值的Context，一旦cancel被调用，即取消该创建的context
    func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
    
    
    // 带有效期cancel返回值的Context，即必须到达指定时间点调用的cacel方法才会被执行
    func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
    
    
    // 带超时时间cancel返回值的Context，类似Deadline，前者是时间点，后者为时间间隔
    // 相当于WithDeadline(parent, time.Now().Add(timeout)).
    func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
    
    
    // WithValue 函数和取消 Context 无关，它是为了生成一个绑定了一个键值对数据的 Context，这个绑定的数据可以通过 Context.Value 方法访问到
    func WithValue(parent Context, key, val interface{}) Context

**(左右滑动查看完整代码图片)**

配合Context提供的Done方法，子goroutine可以检查自身是否被父级节点Cancel。

select { 
        case <-ctx.Done(): 
           // 当子goroutine收到取消信号，即做一些相关处理，例如退出Goroutine。
    }

**(左右滑动查看完整代码图片)**

**注：**父节点Context可以主动通过调用cancel方法取消子节点Context，而子节点Context只能被动等待。同时父节点Context自身一旦被取消（如其上级节点Cancel），其下的所有子节点Context均会自动被取消。

举例说明，Context是如何在Goroutine中传播控制的。

**例1. 通过取消函数WithCancel()传播**

func someHandler() {
      // 通过调用Background创建父节点parentContext
      parentContext := context.Background()
      // 创建通过WithCancel方法继承Background的子节点childContext
      childContext, cancel := context.WithCancel(parentContext)
      go doSth(childContext, "child [1]")
      go doSth(childContext, "child [2]")
    
    
      //模拟程序运行 - Sleep 3秒
      time.Sleep(3 * time.Second)
      cancel()
      //等待取消信号能被子Context读到
      time.Sleep(2 * time.Second)
    }
    
    
    //每1秒work一下，同时会判断ctx是否被取消，如果是就退出
    func doSth(ctx context.Context, name string) {
      var i = 1
      for {
        //模拟具体work - Sleep 1秒
        time.Sleep(1 * time.Second)
        select {
        case <-ctx.Done():
          fmt.Printf("%s done!\n", name)
          return
        default:
          fmt.Printf("%s had worked %d seconds \n", name, i)
        }
        i++
      }
    }
    
    
    func main() {
      fmt.Println("start.")
      someHandler()
      fmt.Println("end.")
    }

**(左右滑动查看完整代码图片)**

输出

start.
    child [2] had worked 1 seconds 
    child [1] had worked 1 seconds 
    child [2] had worked 2 seconds 
    child [1] had worked 2 seconds 
    child [1] done!
    child [2] done!
    end.

**(左右滑动查看完整代码图片)**

**例2. 通过超时控制函数传播**

func someHandler() {
      // 通过调用Background创建父节点parentContext
      parentContext := context.Background()
      // 创建通过WithTimeout方法继承Background的子节点childContext
      childContext, cancel := context.WithTimeout(parentContext, 3*time.Second)
      go doSth(childContext, "child [1]")
      go doSth(childContext, "child [2]")
    
    
      //模拟程序运行 - Sleep 10秒
      time.Sleep(10 * time.Second)
      cancel()
      //等待取消信号能被子Context读到
      time.Sleep(2 * time.Second)
    }
    
    
    //每1秒work一下，同时会判断ctx是否被取消，如果是就退出
    func doSth(ctx context.Context, name string) {
      var i = 1
      for {
        //模拟具体work - Sleep 1秒
        time.Sleep(1 * time.Second)
        select {
        case <-ctx.Done():
          fmt.Printf("%s done!\n", name)
          return
        default:
          fmt.Printf("%s had worked %d seconds \n", name, i)
        }
        i++
      }
    }
    
    
    func main() {
      fmt.Println("start.")
      someHandler()
      fmt.Println("end.")
    }

**(左右滑动查看完整代码图片)**

输出

start.
    child [2] had worked 1 seconds 
    child [1] had worked 1 seconds 
    child [2] had worked 2 seconds 
    child [1] had worked 2 seconds 
    child [2] done!
    child [1] done!
    end.

**(左右滑动查看完整代码图片)**

**注：**由于在WithTimeout中设置的是设置的是3秒，即程序等不到canle()函数（10秒之后）的执行，就已经通过<-ctx.Done()通知到子Goroutine了。WithDeadline和WithTimeout类似，就不再赘述。

![3e4130a07887581c507e8f3df70a7f9e.gif][]

**使用原则**

使用Context的程序包需要遵循如下的原则来满足接口的一致性。

*  不要把Context存在一个结构体当中，显式地传入函数。Context变量需要作为第一个参数使用，一般命名为ctx；
 *  即使方法允许，也不要传入一个nil的Context，如果你不确定你要用什么Context的时候传一个context.TODO；
 *  使用context的Value相关方法只应该用于在程序和接口中传递的和请求相关的元数据，不要用它来传递一些可选的参数；
 *  同样的Context可以用来传递到不同的goroutine中，Context在多个goroutine中是安全的；

**开放性思考：context是一个优雅的设计吗？**