在用 Golang 开发过程中，我们一定能在代码里很多函数或方法都会传递 context, 也会经常遇到这样的报错 context deadline exceeded。你有想过或去探究过 context 到底是什么吗，为什么会遇到上述的报错。在这里我们就分析一下 context 是什么及用途。 首选 Golang 中的 context 值得是 context.Context 接口,Golang 在 1.7 版本中引入标准库的接口。context 主要用来在 goroutine 之间传递上下文信息，包括：取消信号、截止时间、key-value 等。
Context 定义
Context 接口定义如下
type Context interface {
// 返回 context.Context的截止时间（也就是取消时间）
Deadline() (deadline time.Time, ok bool)
// 返回一个 Channel，这个 Channel 会在当前操作完成或者上下文被取消之后关闭，多次调用 Done 方法会返回同一个 Channel
Done() <-chan struct{}
// 返回 context.Context 结束的原因
Err() error
// 从 context.Context 中获取键对应的值, 该方法可以用来传递请求特定的数据
Value(key interface{}) interface{}
}
Context 实现
首先我们思考为什么Golang 中需要 Context。用我们最熟悉的例子 http server 来解释, Go 服务每次都是启动一个新的 goroutine 来处理每一个请求，在这个请求的操作往往会启动新 goroutine 访问数据库或其他服务，如果此时客户端断开了连接，后续的消耗资源的操作就完全没必要了。所以我们需要一个在 goroutine 之间同步取消信号，截止时间的机制或者特定请求数据。而 Context 被设计出来就是帮我们实现这个目标。
|-----------| |-----------| |-----------|
| goroutine |-------> | goroutine |-------> | goroutine |
|-----------| |-----------| |-----------|
默认 Context
context 包中最常用的方法还是 context.Background、context.TODO，这两个方法都会返回预先初始化好的私有变量 background 和 todo。这两个私有变量都是通过 new(emptyCtx) 语句初始化的，它们是指向私有结构体 context.emptyCtx 的指针。
func Background() Context {
return background
}
func TODO() Context {
return todo
}
通过下面代码可以看出 emptyCtx 就是 Context 的实现，只不过没有实际功能。 我们一般用 context.Background 作为根 context; 在不确定使用哪种 context 时用 context.Todo 一般起到占位的作用
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 实现了下面的这个接口，则是能取消的 context。源码中有两个类型实现了 canceler 接口：*cancelCtx 和 *timerCtx
type canceler interface {
cancel(removeFromParent bool, err error)
Done() <-chan struct{}
}
context.cancelCtx
首先函数 WithCancel 就是我们用来创建可以取消的 context(context.cancelCtx) 的入口。
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
// 将传入的上下文包装成私有结构体 context.cancelCtx
c := newCancelCtx(parent)
// 构建父子上下文之间的关联，当父上下文被取消时，子上下文也会被取消
propagateCancel(parent, &c)
return &c, func() { c.cancel(true, Canceled) }
}
我们重点看 propagateCancel 的实现
func propagateCancel(parent Context, child canceler) {
done := parent.Done()
// 父 context 是 emptyCtx
if done == nil {
return // parent is never canceled
}
select {
case <-done:
// parent is already canceled
child.cancel(false, parent.Err())
return
default:
}
// 找到可以取消的父 context
if p, ok := parentCancelCtx(parent); ok {
p.mu.Lock()
if p.err != nil {
// 父节点已经被取消了，子节点也要取消
child.cancel(false, p.err)
} else {
// 父节点未取消
if p.children == nil {
p.children = make(map[canceler]struct{})
}
// 与父 context 关联
p.children[child] = struct{}{}
}
p.mu.Unlock()
} else {
// 如果没有找到可取消的父 context，新启动一个协程监控父节点或子节点取消信号
atomic.AddInt32(&goroutines, +1)
go func() {
select {
case <-parent.Done():
child.cancel(false, parent.Err())
case <-child.Done():
}
}()
}
context.propagateCancel 的作用是把子 context 和父 context 关联起来，保证在 parent 被取消时，child 也会收到对应的信号，达到父 context 取消，子 context 也能同时取消的目的。
下面重点看一下 context.cancelCtx 的 cancel 方法
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
if err == nil {
panic("context: internal error: missing cancel error")
}
c.mu.Lock()
if c.err != nil {
c.mu.Unlock()
return // 已经被其他协程取消
}
c.err = err
// 关闭 channel，通知其他协程
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.timerCtx
timerCtx 基于 cancelCtx，只是多了一个 time.Timer 和一个 deadline。Timer 会在 deadline 到来时，自动取消 context。
type timerCtx struct {
cancelCtx
timer *time.Timer // Under cancelCtx.mu.
deadline time.Time
}
创建 timerCtx 的函数
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) {
// 如果父节点 context 的 deadline 早于指定时间。直接构建一个可取消的 context。
// 原因是一旦父节点超时，自动调用 cancel 函数，子节点也会随之取消。
// 所以不用单独处理子节点的计时器时间到了之后，自动调用 cancel 函数
if cur, ok := parent.Deadline(); ok && cur.Before(d) {
// The current deadline is already sooner than the new one.
return WithCancel(parent)
}
// 创建 timerCtx
c := &timerCtx{
cancelCtx: newCancelCtx(parent),
deadline: d,
}
// 与父节点关联
propagateCancel(parent, c)
// 计算当前距离 deadline 的时间
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 {
//dur 后 timer 会自动调用 cancel 函数。自动取消
c.timer = time.AfterFunc(dur, func() {
c.cancel(true, DeadlineExceeded)
})
}
return c, func() { c.cancel(true, Canceled) }
}
timerCtx 首先是一个 cancelCtx，所以它能取消。看下 cancel() 方法：
func (c *timerCtx) cancel(removeFromParent bool, err error) {
// 直接调用 cancelCtx 的取消方法
c.cancelCtx.cancel(false, err)
if removeFromParent {
// 从父节点中删除子节点
removeChild(c.cancelCtx.Context, c)
}
c.mu.Lock()
if c.timer != nil {
// 关掉定时器，这样，在deadline 到来时，不会再次取消
c.timer.Stop()
c.timer = nil
}
c.mu.Unlock()
}
总结：context 实现取消和定时取消的核心是 context.cancelCtx 和 context.timerCtx。
context 传递数据
context.valueCtx
在 Golang 中使用 context.valueCtx 来传递上下文的数据，定义如下
type valueCtx struct {
Context
key, val interface{}
}
// 创建 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 中存储的键值对与 context.valueCtx.Value 方法中传入的参数不匹配
// 就会从父上下文中查找该键对应的值直到在某个父上下文中返回 nil 或者查找到对应的值
func (c *valueCtx) Value(key interface{}) interface{} {
if c.key == key {
return c.val
}
return c.Context.Value(key)
}
在 context 传递数据的场景一般很有限，比较常见的使用场景是传递请求对应用户 token 以及用于进行分布式追踪的 trace id。不建议用来传递请求参数。 我用下面这种图来展示 Context 的关键实现
Context 使用
context 超时取消
这里我们以一个 Http 服务接口中包含访问其他服务的操作来举例
func main() {
http.HandleFunc("/test", testHandler)
err := http.ListenAndServe("0.0.0.0:8000", nil)
if err != nil {
log.Println(err)
}
}
func testHandler(w http.ResponseWriter, r *http.Request) {
// 初始化一个超时 context
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
defer cancel()
getMessage(ctx)
}
func getMessage(ctx context.Context) {
// 新建带 context 超时取消的 http 请求实例
req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "http://127.0.0.1:8008/test", nil)
client := &http.Client{}
res, err := client.Do(req)
if res != nil {
fmt.Printf("res: %v", res.StatusCode)
defer res.Body.Close()
}
if err != nil {
fmt.Printf("%v", err)
}
}
请求服务不超时则 console 输出 res: 200
请求服务超时则 console 输出 Get "http://127.0.0.1:8008/test": context deadline exceeded
context 传递 trace
// 初始化传递 trace 的 context
func NewContext(ctx context.Context, t Trace) context.Context {
return context.WithValue(ctx, _ctxkey, t)
}
// 初始化一个 trace 实例
func ServerTrace(ctx context.Context, operationName string) context.Context {
t := New(operationName)
defer t.Finish(nil)
t.SetTitle(operationName)
t.SetTag(String(TagSpanKind, "server"))
return NewContext(ctx, t)
}
// 从 context 获取 trace
func FromContext(ctx context.Context) (t Trace, ok bool) {
t, ok = ctx.Value(_ctxkey).(Trace)
return
}
