• #">设计原理 #
  • #">默认上下文 #
  • #">取消信号 #
  • #">传值方法 #
  • #">小结 #

    上下文 context.Context Go 语言中用来设置截止日期、同步信号，传递请求相关值的结构体。上下文与 Goroutine 有比较密切的关系，是 Go 语言中独特的设计，在其他编程语言中我们很少见到类似的概念。
    context.Context 是 Go 语言在 1.7 版本中引入标准库的接口1，该接口定义了四个需要实现的方法，其中包括：

    1. Deadline — 返回 context.Context 被取消的时间，也就是完成工作的截止日期；
    2. Done — 返回一个 Channel，这个 Channel 会在当前工作完成或者上下文被取消后关闭，多次调用 Done 方法会返回同一个 Channel；
    3. Err — 返回 context.Context 结束的原因，它只会在 Done 方法对应的 Channel 关闭时返回非空的值；
      1. 如果 context.Context 被取消，会返回 Canceled 错误；
      2. 如果 context.Context 超时，会返回 DeadlineExceeded 错误；

    4. Value — 从 context.Context 中获取键对应的值，对于同一个上下文来说，多次调用 Value 并传入相同的 Key 会返回相同的结果，该方法可以用来传递请求特定的数据；

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

      context 包中提供的 context.Background、context.TODO、context.WithDeadline 和 context.WithValue 函数会返回实现该接口的私有结构体，我们会在后面详细介绍它们的工作原理。

      设计原理 #

      在 Goroutine 构成的树形结构中对信号进行同步以减少计算资源的浪费是 context.Context 的最大作用。Go 服务的每一个请求都是通过单独的 Goroutine 处理的2，HTTP/RPC 请求的处理器会启动新的 Goroutine 访问数据库和其他服务。
      如下图所示，我们可能会创建多个 Goroutine 来处理一次请求，而 context.Context 的作用是在不同 Goroutine 之间同步请求特定数据、取消信号以及处理请求的截止日期。
      上下文 Context - 图1
      图 6-1 Context 与 Goroutine 树
      每一个 context.Context 都会从最顶层的 Goroutine 一层一层传递到最下层。context.Context 可以在上层 Goroutine 执行出现错误时，将信号及时同步给下层。
      上下文 Context - 图2
      图 6-2 不使用 Context 同步信号
      如上图所示，当最上层的 Goroutine 因为某些原因执行失败时，下层的 Goroutine 由于没有接收到这个信号所以会继续工作；但是当我们正确地使用 context.Context 时，就可以在下层及时停掉无用的工作以减少额外资源的消耗：
      上下文 Context - 图3
      图 6-3 使用 Context 同步信号
      我们可以通过一个代码片段了解 context.Context 是如何对信号进行同步的。在这段代码中，我们创建了一个过期时间为 1s 的上下文，并向上下文传入 handle 函数，该方法会使用 500ms 的时间处理传入的请求： ```go func main() { ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second) defer cancel()

      go handle(ctx, 500*time.Millisecond) select { case <-ctx.Done():

      1.  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) } }

    1. 因为过期时间大于处理时间，所以我们有足够的时间处理该请求，运行上述代码会打印出下面的内容：
    2. ```go
    3. $ go run context.go
    4. process request with 500ms
    5. main context deadline exceeded

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

    1. $ go run context.go
    2. main context deadline exceeded
    3. handle context deadline exceeded

    相信这两个例子能够帮助各位读者理解 context.Context 的使用方法和设计原理 — 多个 Goroutine 同时订阅 ctx.Done() 管道中的消息，一旦接收到取消信号就立刻停止当前正在执行的工作。

    默认上下文 #

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

    1. func Background() Context {
    2.     return background
    3. }
    5. func TODO() Context {
    6.     return todo
    7. }

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

    1. type emptyCtx int
    3. func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
    4.     return
    5. }
    7. func (*emptyCtx) Done() <-chan struct{} {
    8.     return nil
    9. }
    11. func (*emptyCtx) Err() error {
    12.     return nil
    13. }
    15. func (*emptyCtx) Value(key interface{}) interface{} {
    16.     return nil
    17. }

    从上述代码中，我们不难发现 context.emptyCtx 通过空方法实现了 context.Context 接口中的所有方法，它没有任何功能。
    上下文 Context - 图4
    图 6-4 Context 层级关系
    从源代码来看，context.Background 和 context.TODO 也只是互为别名，没有太大的差别，只是在使用和语义上稍有不同：

    • context.Background 是上下文的默认值，所有其他的上下文都应该从它衍生出来；
    • context.TODO 应该仅在不确定应该使用哪种上下文时使用；

    在多数情况下，如果当前函数没有上下文作为入参，我们都会使用 context.Background 作为起始的上下文向下传递。

    取消信号 #

    context.WithCancel 函数能够从 context.Context 中衍生出一个新的子上下文并返回用于取消该上下文的函数。一旦我们执行返回的取消函数，当前上下文以及它的子上下文都会被取消，所有的 Goroutine 都会同步收到这一取消信号。
    上下文 Context - 图5
    图 6-5 Context 子树的取消
    我们直接从 context.WithCancel 函数的实现来看它到底做了什么：

    1. func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
    2.     c := newCancelCtx(parent)
    3.     propagateCancel(parent, &c)
    4.     return &c, func() { c.cancel(true, Canceled) }
    5. }
    • context.newCancelCtx 将传入的上下文包装成私有结构体 context.cancelCtx；

    • context.propagateCancel 会构建父子上下文之间的关联，当父上下文被取消时，子上下文也会被取消：

      1. func propagateCancel(parent Context, child canceler) {
      2.   done := parent.Done()
      3.   if done == nil {
      4.       return // 父上下文不会触发取消信号
      5.   }
      6.   select {
      7.   case <-done:
      8.       child.cancel(false, parent.Err()) // 父上下文已经被取消
      9.       return
      10.   default:
      11.   }
      13.   if p, ok := parentCancelCtx(parent); ok {
      14.       p.mu.Lock()
      15.       if p.err != nil {
      16.           child.cancel(false, p.err)
      17.       } else {
      18.           p.children[child] = struct{}{}
      19.       }
      20.       p.mu.Unlock()
      21.   } else {
      22.       go func() {
      23.           select {
      24.           case <-parent.Done():
      25.               child.cancel(false, parent.Err())
      26.           case <-child.Done():
      27.           }
      28.       }()
      29.   }
      30. }

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

    1. 当 parent.Done() == nil，也就是 parent 不会触发取消事件时，当前函数会直接返回；
    2. 当 child 的继承链包含可以取消的上下文时，会判断 parent 是否已经触发了取消信号；
      • 如果已经被取消，child 会立刻被取消；
      • 如果没有被取消，child 会被加入 parent 的 children 列表中，等待 parent 释放取消信号；
    3. 当父上下文是开发者自定义的类型、实现了 context.Context 接口并在 Done() 方法中返回了非空的管道时；
      1. 运行一个新的 Goroutine 同时监听 parent.Done() 和 child.Done() 两个 Channel；
      2. 在 parent.Done() 关闭时调用 child.cancel 取消子上下文；

    context.propagateCancel 的作用是在 parent 和 child 之间同步取消和结束的信号，保证在 parent 被取消时，child 也会收到对应的信号，不会出现状态不一致的情况。
    context.cancelCtx 实现的几个接口方法也没有太多值得分析的地方，该结构体最重要的方法是 context.cancelCtx.cancel，该方法会关闭上下文中的 Channel 并向所有的子上下文同步取消信号：

    1. func (c *cancelCtx) cancel(removeFromParent bool, err error) {
    2.     c.mu.Lock()
    3.     if c.err != nil {
    4.         c.mu.Unlock()
    5.         return
    6.     }
    7.     c.err = err
    8.     if c.done == nil {
    9.         c.done = closedchan
    10.     } else {
    11.         close(c.done)
    12.     }
    13.     for child := range c.children {
    14.         child.cancel(false, err)
    15.     }
    16.     c.children = nil
    17.     c.mu.Unlock()
    19.     if removeFromParent {
    20.         removeChild(c.Context, c)
    21.     }
    22. }

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

    1. func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
    2.     return WithDeadline(parent, time.Now().Add(timeout))
    3. }
    5. func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
    6.     if cur, ok := parent.Deadline(); ok && cur.Before(d) {
    7.         return WithCancel(parent)
    8.     }
    9.     c := &timerCtx{
    10.         cancelCtx: newCancelCtx(parent),
    11.         deadline:  d,
    12.     }
    13.     propagateCancel(parent, c)
    14.     dur := time.Until(d)
    15.     if dur <= 0 {
    16.         c.cancel(true, DeadlineExceeded) // 已经过了截止日期
    17.         return c, func() { c.cancel(false, Canceled) }
    18.     }
    19.     c.mu.Lock()
    20.     defer c.mu.Unlock()
    21.     if c.err == nil {
    22.         c.timer = time.AfterFunc(dur, func() {
    23.             c.cancel(true, DeadlineExceeded)
    24.         })
    25.     }
    26.     return c, func() { c.cancel(true, Canceled) }
    27. }

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

    1. type timerCtx struct {
    2.     cancelCtx
    3.     timer *time.Timer // Under cancelCtx.mu.
    5.     deadline time.Time
    6. }
    8. func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
    9.     return c.deadline, true
    10. }
    12. func (c *timerCtx) cancel(removeFromParent bool, err error) {
    13.     c.cancelCtx.cancel(false, err)
    14.     if removeFromParent {
    15.         removeChild(c.cancelCtx.Context, c)
    16.     }
    17.     c.mu.Lock()
    18.     if c.timer != nil {
    19.         c.timer.Stop()
    20.         c.timer = nil
    21.     }
    22.     c.mu.Unlock()
    23. }

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

    传值方法 #

    在最后我们需要了解如何使用上下文传值，context 包中的 context.WithValue 能从父上下文中创建一个子上下文，传值的子上下文使用 context.valueCtx 类型：

    1. func WithValue(parent Context, key, val interface{}) Context {
    2.     if key == nil {
    3.         panic("nil key")
    4.     }
    5.     if !reflectlite.TypeOf(key).Comparable() {
    6.         panic("key is not comparable")
    7.     }
    8.     return &valueCtx{parent, key, val}
    9. }

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

    1. type valueCtx struct {
    2.     Context
    3.     key, val interface{}
    4. }
    6. func (c *valueCtx) Value(key interface{}) interface{} {
    7.     if c.key == key {
    8.         return c.val
    9.     }
    10.     return c.Context.Value(key)
    11. }

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

    小结 #

    Go 语言中的 context.Context 的主要作用还是在多个 Goroutine 组成的树中同步取消信号以减少对资源的消耗和占用，虽然它也有传值的功能，但是这个功能我们还是很少用到。
    在真正使用传值的功能时我们也应该非常谨慎，使用 context.Context 进行传递参数请求的所有参数一种非常差的设计，比较常见的使用场景是传递请求对应用户的认证令牌以及用于进行分布式追踪的请求 ID。