Golang Context 的原理与实战

本文让我们一起来学习 golang context 的使用和标准库中的context的实现。

golang context 包 一开始只是 google 内部使用的一个 golang 包，在 golang 1.7的版本中正式被引入标准库。下面开始学习。

简单介绍

在学习 context 包之前，先看几种日常开发中经常会碰到的业务场景：

1. 业务需要对访问的数据库，rpc ，或api接口，为了防止这些依赖导致我们的服务超时，需要针对性的做超时控制。
2. 为了详细了解服务性能，记录详细的调用链log。

上面两种场景在web中是比较常见的，context 包就是为了方便我们应对此类场景而使用的。

接下来, 我们首先学习 context 包有哪些方法供我们使用；接着举一些例子，使用 context 包应用在我们上述场景中去解决我们遇到的问题；最后从源码角度学习 context 内部实现，了解 context 的实现原理。

context 包

context 定义

context 包中实现了多种 context 对象。context 是一个接口，用来描述一个程序的上下文。接口中提供了四个抽象的方法，定义如下：

type context interface {
  deadline() (deadline time.time, ok bool)
  done() <-chan struct{}
  err() error
  value(key interface{}) interface{}
}

• deadline() 返回的是上下文的截至时间，如果没有设定，ok 为 false
• done() 当执行的上下文被取消后，done返回的chan就会被close。如果这个上下文不会被取消，返回nil
• err() 有几种情况:
  • 如果done() 返回 chan 没有关闭，返回nil
  • 如果done() 返回的chan 关闭了， err 返回一个非nil的值，解释为什么会done()
    • 如果canceled，返回 "canceled"
    • 如果超过了 deadline，返回 "deadlineesceeded"
• value(key) 返回上下文中 key 对应的 value 值

context 构造

为了使用 context，我们需要了解 context 是怎么构造的。

context 提供了两个方法做初始化：

func background() context{}
func todo() context {}

上面方法均会返回空的 context，但是 background 一般是所有 context 的基础，所有 context 的源头都应该是它。todo 方法一般用于当传入的方法不确定是哪种类型的 context 时，为了避免 context 的参数为nil而初始化的 context。

其他的 context 都是基于已经构造好的 context 来实现的。一个 context 可以派生多个子 context。基于 context 派生新context 的方法如下：

func withcancel(parent context) (ctx context, cancel cancelfunc){}
func withdeadline(parent context, d time.time) (context, cancelfunc) {}
func withtimeout(parent context, timeout time.duration) (context, cancelfunc) {}

上面三种方法比较类似，均会基于 parent context 生成一个子 ctx，以及一个 cancel 方法。如果调用了cancel 方法，ctx 以及基于 ctx 构造的子 context 都会被取消。不同点在于 withcancel 必需要手动调用 cancel 方法，withdeadline
可以设置一个时间点，withtimeout 是设置调用的持续时间，到指定时间后，会调用 cancel 做取消操作。

除了上面的构造方式，还有一类是用来创建传递 traceid， token 等重要数据的 context。

func withvalue(parent context, key, val interface{}) context {}

withvalue 会构造一个新的context，新的context 会包含一对 key-value 数据，可以通过context.value(key) 获取存在 ctx 中的 value 值。

通过上面的理解可以直到，context 是一个树状结构，一个 context 可以派生出多个不一样的context。我们大概可以画一个如下的树状图：

一个background，衍生出一个带有traceid的valuectx，然后valuectx衍生出一个带有cancelctx
的context。最终在一些db查询，http查询，rpc沙逊等异步调用中体现。如果出现超时，直接把这些异步调用取消，减少消耗的资源，我们也可以在调用时，通过value 方法拿到traceid，并记录下对应请求的数据。

当然，除了上面的几种 context 外，我们也可以基于上述的 context 接口实现新的context.

使用方法

下面我们举几个例子，学习上面讲到的方法。

超时查询的例子

在做数据库查询时，需要对数据的查询做超时控制，例如：

ctx = context.withtimeout(context.background(), time.second)
rows, err := pool.querycontext(ctx, "select * from products where id = ?", 100)

上面的代码基于 background 派生出一个带有超时取消功能的ctx，传入带有context查询的方法中，如果超过1s未返回结果，则取消本次的查询。使用起来非常方便。为了了解查询内部是如何做到超时取消的，我们看看db内部是如何使用传入的ctx的。

在查询时，需要先从pool中获取一个db的链接，代码大概如下：

// src/database/sql/sql.go
// func (db *db) conn(ctx context.context, strategy connreusestrategy) *driverconn, error)

// 阻塞从req中获取链接，如果超时，直接返回
select {
case <-ctx.done():
  // 获取链接超时了，直接返回错误
  // do something
  return nil, ctx.err()
case ret, ok := <-req:
  // 拿到链接，校验并返回
  return ret.conn, ret.err
}

req 也是一个chan，是等待链接返回的chan，如果done() 返回的chan 关闭后，则不再关心req的返回了，我们的查询就超时了。

在做sql prepare、sql query 等操作时，也会有类似方法：

select {
default:
// 校验是否已经超时，如果超时直接返回
case <-ctx.done():
  return nil, ctx.err()
}
// 如果还没有超时，调用驱动做查询
return queryer.query(query, dargs)

上面在做查询时，首先判断是否已经超时了，如果超时，则直接返回错误，否则才进行查询。

可以看出，在派生出的带有超时取消功能的 context 时，内部方法在做异步操作（比如获取链接，查询等）时会先查看是否已经
done了，如果done，说明请求已超时，直接返回错误；否则继续等待，或者做下一步工作。这里也可以看出，要做到超时控制，需要不断判断 done() 是否已关闭。

链路追踪的例子

在做链路追踪时，context 也是非常重要的。（所谓链路追踪，是说可以追踪某一个请求所依赖的模块，比如db，redis，rpc下游，接口下游等服务，从这些依赖服务中找到请求中的时间消耗）

下面举一个链路追踪的例子：

// 建议把key 类型不导出，防止被覆盖
type traceidkey struct{}{}

// 定义固定的key
var traceidkey = traceidkey{}

func servehttp(w http.responsewriter, req *http.request){
  // 首先从请求中拿到traceid
  // 可以把traceid 放在header里，也可以放在body中
  // 还可以自己建立一个 （如果自己是请求源头的话）
  traceid := gettraceidfromrequest(req)

  // key 存入 ctx 中
  ctx := context.withvalue(req.context(), traceidkey, traceid)

  // 设置接口1s 超时
  ctx = context.withtimeout(ctx, time.second)

  // query rpc 时可以携带 traceid
  represp := requestrpc(ctx, ...)

  // query db 时可以携带 traceid
  dbresp := requestdb(ctx, ...)

  // ...
}

func requestrpc(ctx context.context, ...) interface{} {
    // 获取traceid，在调用rpc时记录日志
    traceid, _ := ctx.value(traceidkey)
    // request

    // do log
    return
}

上述代码中，当拿到请求后，我们通过req 获取traceid， 并记录在ctx中，在调用rpc，db等时，传入我们构造的ctx，在后续代码中，我们可以通过ctx拿到我们存入的traceid，使用traceid 记录请求的日志，方便后续做问题定位。

当然，一般情况下，context 不会单纯的仅仅是用于 traceid 的记录，或者超时的控制。很有可能二者兼有之。

如何实现

知其然也需知其所以然。想要充分利用好 context，我们还需要学习 context 的实现。下面我们一起学习不同的 context 是如何实现 context 接口的，

空上下文

background(), empty() 均会返回一个空的 context emptyctx。emptyctx 对象在方法 deadline(), done(), err(), value(interface{}) 中均会返回nil，string() 方法会返回对应的字符串。这个实现比较简单，我们这里暂时不讨论。

有取消功能的上下文

withcancel 构造的context 是一个cancelctx实例，代码如下。

type cancelctx struct {
  context

  // 互斥锁，保证context协程安全
  mu       sync.mutex
  // cancel 的时候，close 这个chan
  done     chan struct{}
  // 派生的context
  children map[canceler]struct{}
  err      error
}

withcancel 方法首先会基于 parent 构建一个新的 context，代码如下：

func withcancel(parent context) (ctx context, cancel cancelfunc) {
  c := newcancelctx(parent)  // 新的上下文
  propagatecancel(parent, &c) // 挂到parent 上
  return &c, func() { c.cancel(true, canceled) }
}

其中，propagatecancel 方法会判断 parent 是否已经取消，如果取消，则直接调用方法取消；如果没有取消，会在parent的children 追加一个child。这里就可以看出，context 树状结构的实现。 下面是propatecancel 的实现：

// 把child 挂在到parent 下
func propagatecancel(parent context, child canceler) {
  // 如果parent 为空，则直接返回
  if parent.done() == nil {
    return // parent is never canceled
  }
  
  // 获取parent类型
  if p, ok := parentcancelctx(parent); ok {
    p.mu.lock()
    if p.err != nil {
      // parent has already been canceled
      child.cancel(false, p.err)
    } else {
      if p.children == nil {
        p.children = make(map[canceler]struct{})
      }
      p.children[child] = struct{}{}
    }
    p.mu.unlock()
  } else {
    // 启动goroutine，等待parent/child done
    go func() {
      select {
      case <-parent.done():
        child.cancel(false, parent.err())
      case <-child.done():
      }
    }()
  }
}

done() 实现比较简单，就是返回一个chan，等待chan 关闭。可以看出 done 操作是在调用时才会构造 chan done，done 变量是延时初始化的。

func (c *cancelctx) done() <-chan struct{} {
  c.mu.lock()
  if c.done == nil {
    c.done = make(chan struct{})
  }
  d := c.done
  c.mu.unlock()
  return d
}

在手动取消 context 时，会调用 cancelctx 的 cancel 方法，代码如下：

func (c *cancelctx) cancel(removefromparent bool, err error) {
  // 一些判断,关闭 ctx.done chan
  // ...
  if c.done == nil {
    c.done = closedchan
  } else {
    close(c.done)
  }

  // 广播到所有的child，需要cancel goroutine 了
  for child := range c.children {
    // note: acquiring the child's lock while holding parent's lock.
    child.cancel(false, err)
  }
  c.children = nil
  c.mu.unlock()

  // 然后从父context 中，删除当前的context
  if removefromparent {
    removechild(c.context, c)
  }
}

这里可以看到，当执行cancel时，除了会关闭当前的cancel外，还做了两件事，① 所有的child 都调用cancel方法，② 由于该上下文已经关闭，需要从父上下文中移除当前的上下文。

定时取消功能的上下文

withdeadline, withtimeout 提供了实现定时功能的 context 方法，返回一个timerctx结构体。withdeadline 是给定了执行截至时间，withtimeout 是倒计时时间，withtimeout 是基于withdeadline实现的，因此我们仅看其中的withdeadline
即可。withdeadline 内部实现是基于cancelctx 的。相对于 cancelctx 增加了一个计时器，并记录了 deadline 时间点。下面是timerctx 结构体：

type timerctx struct {
  cancelctx
  // 计时器
  timer *time.timer
  // 截止时间
  deadline time.time
}

withdeadline 的实现：

func withdeadline(parent context, d time.time) (context, cancelfunc) {
  // 若父上下文结束时间早于child，
  // 则child直接挂载在parent上下文下即可
  if cur, ok := parent.deadline(); ok && cur.before(d) {
    return withcancel(parent)
  }

  // 创建个timerctx, 设置deadline
  c := &timerctx{
    cancelctx: newcancelctx(parent),
    deadline:  d,
  }

  // 将context挂在parent 之下
  propagatecancel(parent, c)

  // 计算倒计时时间
  dur := time.until(d)
  if dur <= 0 {
    c.cancel(true, deadlineexceeded) // deadline has already passed
    return c, func() { c.cancel(false, canceled) }
  }
  c.mu.lock()
  defer c.mu.unlock()
  if c.err == nil {
    // 设定一个计时器，到时调用cancel
    c.timer = time.afterfunc(dur, func() {
      c.cancel(true, deadlineexceeded)
    })
  }
  return c, func() { c.cancel(true, canceled) }
}

构造方法中，将新的context 挂在到parent下，并创建了倒计时器定期触发cancel。

timerctx 的cancel 操作，和cancelctx 的cancel 操作是非常类似的。在cancelctx 的基础上，做了关闭定时器的操作

func (c *timerctx) cancel(removefromparent bool, err error) {
  // 调用cancelctx 的cancel 方法 关闭chan，并通知子context。
  c.cancelctx.cancel(false, err)
  // 从parent 中移除
  if removefromparent {
    removechild(c.cancelctx.context, c)
  }
  c.mu.lock()
  // 关掉定时器
  if c.timer != nil {
    c.timer.stop()
    c.timer = nil
  }
  c.mu.unlock()
}

timectx 的 done 操作直接复用了cancelctx 的 done 操作，直接关闭 chan done 成员。

传递值的上下文

withvalue 构造的上下文与上面几种有区别，其构造的context 原型如下：

type valuectx struct {
  // 保留了父节点的context
  context
  key, val interface{}
}

每个context 包含了一个key-value组合。valuectx 保留了父节点的context，但没有像cancelctx 一样保留子节点的context. 下面是valuectx的构造方法：

func withvalue(parent context, key, val interface{}) context {
  if key == nil {
    panic("nil key")
  }
  // key 必须是课比较的，不然无法获取value
  if !reflect.typeof(key).comparable() {
    panic("key is not comparable")
  }
  return &valuectx{parent, key, val}
}

直接将key-value赋值给struct 即可完成构造。下面是获取value 的方法：

func (c *valuectx) value(key interface{}) interface{} {
  if c.key == key {
    return c.val
  }
  // 从父context 中获取
  return c.context.value(key)
}

value 的获取是采用链式获取的方法。如果当前 context 中找不到，则从父context中获取。如果我们希望一个context 多放几条数据时，可以保存一个map 数据到 context 中。这里不建议多次构造context来存放数据。毕竟取数据的成本也是比较高的。

注意事项

最后，在使用中应该注意如下几点：

• context.background 用在请求进来的时候，所有其他context 来源于它。
• 在传入的conttext 不确定使用的是那种类型的时候，传入todo context （不应该传入一个nil 的context)
• context.value 不应该传入可选的参数，应该是每个请求都一定会自带的一些数据。（比如说traceid，授权token 之类的）。在value 使用时，建议把key 定义为全局const 变量，并且key 的类型不可导出，防止数据存在冲突。
• context goroutines 安全。