golang-context详解

Context是什么

cancel 其实就是通过chan + select进行提前中断返回
如果没有context，携程之间怎么做这些交互呢？肯定也能做
跨线程通讯如共享内存，pipe等等都可以做到，但是就需要开发者对通讯设计建模、规划数据同步方式等，这里面还需要考虑内存管理和死锁问题。context相当于程序已经提供了这样一套设计方案（CSP），可以很方便使用。也符合golang的“简单”哲学。
在跨线程场景下，相当于提供了官方的解决方案

Context 只有两个简单的功能：跨 API 或在进程间 1)携带键值对、2)传递取消信号(主动取消、时限/超时自动取消)

Context是Go 语言在 1.7 版本中引入的一个标准库的接口，其定义如下：

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

这个接口定义了四个方法：

Deadline：设置 context.Context 被取消的时间，即截止时间；
Done：返回一个只读Channel，当Context被取消或者到达截止时间，这个 Channel 就会被关闭，表示Context的链路结束，多次调用 Done 方法会返回同一个 Channel
Err：返回 context.Context 结束的原因，它只会在 Done 返回的 Channel 被关闭时才会返回非空的值，返回值有以下两种情况；
- 如果是context.Context 被取消，返回 Canceled
- 如果是context.Context 超时，返回 DeadlineExceeded
Value — 从 context.Context 中获取键对应的值，类似于Map的get方法，对于同一个context，多次调用 Value 并传入相同的 Key会返回相同的结果，如果没有对应的Key,则返回nil，键值对是通过WithValue方法写入的

Context创建

根Context创建

主要有以下两种方式创建根context

context.Backgroud()
context.TODO()

从源代码分析context.Background 和 context.TODO 并没有太多的区别，都是用于创建根context，根context是一个空的context，不具备任何功能。但是一般情况下，如果当前函数没有上下文作为入参，我们都会使用 context.Background创建一个根context 作为起始的上下文向下传递

这两个函数的实现都返回一个 context.emptyCtx 对象的地址：

var (
 background = new(emptyCtx)
 todo       = new(emptyCtx)
)

尽管本质上是一样的，但是区分两个函数是为了在编写代码时，更清晰地表明开发人员在创建这个上下文的意图：

TODO(): 不确定要使用哪个上下文时，可以将其用作占位符
BackGround(): 打算启动已知上下文的地方，通常我们都使用这个

空的上下文没有什么用途。因为 emptyCtx 的 Done()、Err()、Value() 等方法，都返回的 nil。

子Context创建

根context在创建之后，不具备任何的功能，为了让context在我们的程序中发挥作用，我们要依靠context包提供的With系列函数来进行派生
主要有以下几个派生函数：

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

基于当前context，每个with函数都会创建出一个新的context，这样类似于我们熟悉的树结构，当前context称为父context，派生出的新context称为子context。就像下面的context树结构：
在这里插入图片描述

Context有什么用

Context主要有两个用途，也是在项目中经常使用的

用于并发控制，控制协程的优雅退出
上下文的信息传递
总的来说，Context就是用来在父子goroutine间进行值传递以及发送cancel信号的一种机

并发控制

对于一般的服务器而言，都是一致运行着的，等待接收来自客户端或者浏览器的请求做出响应，思考这样一种场景，后台微服务架构中，一般服务器在收到一个请求之后，如果逻辑复杂，不会在一个goroutine中完成，而是会创建出很多的goroutine共同完成这个请求，就像下面这种情况
在这里插入图片描述

有一个请求过来之后，先经过第一次rpc1调用，然后再到rpc2，后面创建执行两个rpc，rpc4里又有一次rpc调用rpc5，等所有 rpc 调用成功后，返回结果。假如在整个调用过程中，rpc1发生了错误，如果没有context存在的话，我们还是得等所有的rpc都执行完才能返回结果，这样其实浪费了不少时间，因为一旦出错，我们完全可以直接再rpc1这里就返回结果了，不用等到后续的rpc都执行完。假设我们在rpc1直接返回失败，不等后续的rpc继续执行，那么其实后续的rpc执行就是没有意义的，浪费计算和IO资源而已。再引入context之后，就可以很好的处理这个问题，在不需要子goroutine执行的时候，可以通过context通知子goroutine优雅的关闭

Done()—— 确定上下文是否完成

无论上下文是因为什么原因结束的，都可以通过调用其 Done() 方法确认：该方法返回一个通道(chan struct{})，该通道会在上下文完成时被关闭，任何监听该通道的函数都会感应到对应上下文完成的事件。

【channel 基础知识】通道有一种常见的用法：不会往通道里写入任何东西，在需要发送信号的时候关闭通道，此时接收操作符（receive operator）会立马收到一个管道类型的零值

通道的等待往往结合 select 一块使用。 select 可以通过多个 case 同时读取多个 channel，如果每个 case 的 channel 都被阻塞则 select 会被阻塞。也会有另外的做法，在 default 做逻辑或者 sleep，将 select 放在循环中，不断的重复检查。

再说回 Done() 方法，它返回一个通道，在 Context 未关闭和关闭的表现：

没有关闭的时候，case <- ctx.Done() 会阻塞住
关闭之后，每次 <- ctx.Done() 都会返回一个零值

下面context.WithCancel一节会有使用示例

context.WithCancel

方法定义如下:

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

context.WithCancel 函数是一个取消控制函数，只需要一个context作为参数，能够从 context.Context 中衍生出一个新的子context和取消函数CancelFunc，通过将这个子context传递到新的goroutine中来控制这些goroutine的关闭，一旦我们执行返回的取消函数CancelFunc，当前上下文以及它的子上下文都会被取消，所有的 Goroutine 都会同步收到取消信号

使用示例：

package main

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

func main() {
   ctx, cancel := context.WithCancel(context.Background())
   go Watch(ctx, "goroutine1")
   go Watch(ctx, "goroutine2")

   time.Sleep(6 * time.Second)   // 让goroutine1和goroutine2执行6s
   fmt.Println("end watching!!!")
   cancel()  // 通知goroutine1和goroutine2关闭
   time.Sleep(1 * time.Second)
}

func Watch(ctx context.Context, name string) {
   for {
      select {
      case <-ctx.Done():
         fmt.Printf("%s exit!\n", name) // 主goroutine调用cancel后，会发送一个信号到ctx.Done()这个channel，这里就会收到信息
         return
      default:
         fmt.Printf("%s watching...\n", name)
         time.Sleep(time.Second)
      }
   }
}

运行结果：

goroutine2 watching...
goroutine1 watching...
goroutine1 watching...
goroutine2 watching...
goroutine2 watching...
goroutine1 watching...
goroutine1 watching...
goroutine2 watching...
goroutine2 watching...
goroutine1 watching...
goroutine1 watching...
goroutine2 watching...
end watching!!!
goroutine1 exit!
goroutine2 exit!

ctx, cancel := context.WithCancel(context.Background())派生出了一个带有返回函数cancel的ctx，并把它传入到子goroutine中，接下来在6s时间内，由于没有执行cancel函数，子goroutine将一直执行default语句，打印监控。6s之后，调用cancel，此时子goroutine会从ctx.Done()这个channel中收到消息，执行return结束

context.WithDeadline

方法定义如下：

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

context.WithDeadline也是一个取消控制函数，方法有两个参数，第一个参数是一个context，第二个参数是截止时间，同样会返回一个子context和一个取消函数CancelFunc。在使用的时候，没有到截止时间，我们可以通过手动调用CancelFunc来取消子context，控制子goroutine的退出，如果到了截止时间，我们都没有调用CancelFunc，子context的Done()管道也会收到一个取消信号，用来控制子goroutine退出

package main

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

func main() {
   ctx, cancel := context.WithDeadline(context.Background(),time.Now().Add(4*time.Second)) // 设置超时时间4当前时间4s之后
   defer cancel()
   go Watch(ctx, "goroutine1")
   go Watch(ctx, "goroutine2")

   time.Sleep(6 * time.Second)   // 让goroutine1和goroutine2执行6s
   fmt.Println("end watching!!!")
}

func Watch(ctx context.Context, name string) {
   for {
      select {
      case <-ctx.Done():
         fmt.Printf("%s exit!\n", name) // 4s之后收到信号
         return
      default:
         fmt.Printf("%s watching...\n", name)
         time.Sleep(time.Second)
      }
   }
}

运行结果：

goroutine1 watching...
goroutine2 watching...
goroutine2 watching...
goroutine1 watching...
goroutine1 watching...
goroutine2 watching...
goroutine1 exit!
goroutine2 exit!
end watching!!!

我们并没有调用cancel函数，但是在过了4s之后，子groutine里ctx.Done()收到了信号，打印出exit，子goroutine退出，这就是WithDeadline派生子context的用法

context.WithTimeout

方法定义：

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

context.WithTimeout和context.WithDeadline的作用类似，都是用于超时取消子context，只是传递的第二个参数有所不同，context.WithTimeout传递的第二个参数不是具体时间，而是时间长度

package main

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

func main() {
   ctx, cancel := context.WithTimeout(context.Background(), 4*time.Second)
   defer cancel()
   go Watch(ctx, "goroutine1")
   go Watch(ctx, "goroutine2")

   time.Sleep(6 * time.Second)   // 让goroutine1和goroutine2执行6s
   fmt.Println("end watching!!!")
}

func Watch(ctx context.Context, name string) {
   for {
      select {
      case <-ctx.Done():
         fmt.Printf("%s exit!\n", name) // 主goroutine调用cancel后，会发送一个信号到ctx.Done()这个channel，这里就会收到信息
         return
      default:
         fmt.Printf("%s watching...\n", name)
         time.Sleep(time.Second)
      }
   }
}

运行结果：

goroutine2 watching...
goroutine1 watching...
goroutine1 watching...
goroutine2 watching...
goroutine2 watching...
goroutine1 watching...
goroutine1 watching...
goroutine2 watching...
goroutine1 exit!
goroutine2 exit!
end watching!!!

程序很简单，与上个context.WithDeadline的样例代码基本一样，只是改变了下派生context的方法为context.WithTimeout，具体体现在第二个参数不再是具体时间，而是变为了4s这个具体的时间长度，执行结果也是一样

上下文的信息传递

context.WithValue

方法定义：

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

context.WithValu 函数从父context中创建一个子context用于传值，函数参数是父context，key，val键值对。返回一个context 项目中这个方法一般用于上下文信息的传递，比如请求唯一id，以及trace_id等，用于链路追踪以及配置透传

使用示例：

package main

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

func func1(ctx context.Context) {
   fmt.Printf("name is: %s", ctx.Value("name").(string))
}

func main() {
   ctx := context.WithValue(context.Background(), "name", "zhangsan")
   go func1(ctx)
   time.Sleep(time.Second)
}

运行结果：

name is: zhangsan

WithValue() 函数定义中，传入的 Context 命名为 parent：再次强调，返回的 Context 与其是派生关系。

func main() {
 a := context.Background()              // 创建上下文
 b := context.WithValue(a, "k1", "v1")  // 塞入一个kv
 c := context.WithValue(b, "k2", "v2")  // 塞入另外一个kv
 d := context.WithValue(c, "k1", "vo1") // 覆盖一个kv

 fmt.Printf("k1 of b: %s\n", b.Value("k1"))
 fmt.Printf("k1 of d: %s\n", d.Value("k1"))
 fmt.Printf("k2 of d: %s\n", d.Value("k2"))
}

上述代码打印的内容：

k1 of b: v1
k1 of d: vo1
k2 of d: v2
直观的感觉是上下文中的键值对可以被覆盖，但看一下 WithValue() 的实现，这种表现并不是真正的覆盖了某些值。

另外，这里的值可以是任何类型，拿出来使用的时候，需要转换成具体的类型。

实现原理
每次调用 WithValue() 函数，会返回一个 *valueCtx 的指针，将 key, val 设置进去(val 可以是任何类型)，并且将之前的 Context 嵌套进去。

valueCtx 的结构如下：

type valueCtx struct {
 Context
 key, val any
}

而 Context.Value() 方法，则是不断的从 Context 中寻找是否有对应的 key 匹配，如果匹配则返回 val；如果不匹配在包裹的 Context 中继续寻找。

如果不断地通过 WithValue() 同一个的 key 更新上下文，写入和读取就像使用一个栈，后边被设置进去的会被先读取到。 Value() 是一个递归解嵌套的过程，终止条件就是 Context 为 emptyCtx 或找到对应 key。

Context 的不足

Context 的作用很明显，当我们在开发后台服务时，能帮助我们完成对一组相关 goroutine 的控制并传递共享数据。注意是后台服务，而不是所有的场景都需要使用 Context。

Go 官方建议我们把 Context 作为函数的第一个参数，甚至连名字都准备好了。这造成一个后果：因为我们想控制所有的协程的取消动作，所以需要在几乎所有的函数里加上一个 Context 参数。很快，我们的代码里，context 将像病毒一样扩散的到处都是。

另外，像 WithCancel、WithDeadline、WithTimeout、WithValue 这些创建函数，实际上是创建了一个个的链表结点而已。我们知道，对链表的操作，通常都是 O(n) 复杂度的，效率不高。

Context 解决的核心问题是 cancelation，即便它不完美，但它却简洁地解决了这个问题。