go 源码解析 - context

个人主页：二郎腿 (erlangtui.top)

本文代码基于 go1.17.13，src/context/context.go

一、简述

• context 包提供了在其他跨API边界和 goroutine 之间传递特定数据、取消操作以及设置截止时间的机制，可以帮助用户管理 goroutine 的生命周期，以更好地管理并发操作，避免资源泄漏和优雅地处理取消操作；
• context 是线程安全的，可以在多个 goroutine 之间共享和传递，但不应该在每个函数中传递，而是将其作为参数传递给函数的顶层调用，并将其传递给需要使用 context 的函数，这样可以更好地控制 context 的生命周期；

二、基本原理

• context.Background()：返回一个空的上下文，是所有上下文的根节点，通常用于整个应用程序的上下文；
• context.TODO()：类似于 context.Background()，在不清楚应该使用哪个上下文时可以临时使用；
• context.WithCancel(parent)：返回一个可取消的上下文和取消函数，当调用取消函数时，该上下文和其子上下文都会收到取消信号；
• context.WithDeadline(parent, d)：返回一个带有截止时间的上下文和取消函数，当调用取消函数或截止时间到期时，该上下文和其子上下文都会收到取消信号；
• context.WithTimeout(parent, timeout)：返回一个带有超时时间的上下文和取消函数，当调用取消函数或超过指定的超时时间后，该上下文和其子上下文都会收到取消信号；
• context.WithValue(parent, key, value)：返回一个带有键值对的上下文，可以在 goroutine 之间传递请求特定的数据；
• Background() 或 TODO() 可以创建一个根 Context 对象；
• WithCancel、WithDeadline、WithTimeout 和 WithValue 函数接受一个 Context(父类) 并返回一个派生 Context(子类) 和一个 CancelFunc；
• 调用 CancelFunc 会取消子协程及其子协程，移除父协程对子协程的引用，并停止所有相关的计时器，未能调用 CancelFunc 会泄漏子协程及其子协程，直到父进程被取消或计时器触发；
• 在并发操作中，可以通过 Context 对象的 Done() 方法来获取一个 chan ，当 Context 被取消或者超时时，这个 chan 会关闭，可以通过监听这个通道来处理取消或超时的情况；

三、基本用法

1，应用场景

• 主要用于处理并发请求的超时、参数传递、及时取消等，能够有效控制请求过程中的资源使用和避免潜在的资源泄露；
• 广泛应用于go的http模块、echo框架和gin框架中，以及rpc请求、并发数控制、错误传播等场景；

2，注意事项

• 不要将 Context 塞到结构体的里，直接将 Context 类型作为函数的第一参数，而且一般都命名为 ctx；
• 不要向函数传入一个 nil 的 Context的，如果不确定要使用哪个上下文，可以传递context.TODO()；
• 不要把本应该作为函数参数的类型塞到 context 中的，仅将 context 值用于传输进程和 api 的请求作用域数据，例如：登陆的 session、cookie 等；
• 同一个 context 可以被传递给运行在不同 goroutine 中的函数，context 对于多个 goroutine 同时使用是安全的的；
• 对服务器的传入请求应该创建上下文，对服务器的传出调用应该接受上下文，可以选择使用WithCancel、WithDeadline、WithTimeout 和 WithValue 函数接创建的派生上下文；
• go -vet 工具检查在所有控制流路径上是否使用了 CancelFuncs；

3，简单示例

package main

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

func reqTaskCancel(ctx context.Context, name string) {
	for {
		select {
		case <-ctx.Done():
			fmt.Println("stop", name, ctx.Err())
			return
		default:
			fmt.Println(name, "send request")
			time.Sleep(1 * time.Second)
		}
	}
}

func contextCancel() {
	ctx, cancel := context.WithCancel(context.Background())
	go reqTaskCancel(ctx, "worker1")
	time.Sleep(3 * time.Second)
	cancel()
	time.Sleep(3 * time.Second)
}

func reqTaskDeadline(ctx context.Context, name string) {
	for {
		select {
		case <-ctx.Done():
			fmt.Println("stop", name, ctx.Err())
			return
		default:
			fmt.Println(name, "send request")
			time.Sleep(1 * time.Second)
		}
	}
}

func contextDeadLine() {
	ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(1*time.Second))
	go reqTaskDeadline(ctx, "worker1")
	go reqTaskDeadline(ctx, "worker2")

	time.Sleep(3 * time.Second)
	fmt.Println("before cancel")
	cancel()
	time.Sleep(3 * time.Second)
}

type options struct{ Interval time.Duration }

func reqTaskValue(ctx context.Context, name string) {
	for {
		select {
		case <-ctx.Done():
			fmt.Println("stop", name, ctx.Err())
			return
		default:
			fmt.Println(name, "send request", ctx.Err())
			op := ctx.Value("options").(*options)
			time.Sleep(op.Interval * time.Second)
		}
	}
}

func contextValue() {
	ctx, cancel := context.WithCancel(context.Background())
	vCtx := context.WithValue(ctx, "options", &options{1})

	go reqTaskValue(vCtx, "worker1")
	go reqTaskValue(vCtx, "worker2")

	time.Sleep(3 * time.Second)
	cancel()
	time.Sleep(3 * time.Second)
}

func contextTimeout() {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	go reqTaskCancel(ctx, "worker1")
	go reqTaskCancel(ctx, "worker2")

	time.Sleep(3 * time.Second)
	fmt.Println("before cancel")
	cancel()
	time.Sleep(3 * time.Second)
}

func main() {
	contextCancel()
	fmt.Printf("cancel end -------------------\n\n")
	time.Sleep(3 * time.Second)

	contextDeadLine()
	fmt.Printf("deadline end -------------------\n\n")
	time.Sleep(3 * time.Second)

	contextTimeout()
	fmt.Printf("timeout end -------------------\n\n")
	time.Sleep(3 * time.Second)
	
	contextValue()
	fmt.Printf("value end -------------------\n\n")
}

四、源码解读

1，Context

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

• context.Context 是一个接口类型，定义了一组方法来处理上下文相关的操作；
• Deadline 返回该上下文的截止时间，未设置截止时间时返回 ok==false，连续调用将返回相同的结果；
• Done() 返回一个只读的 chan：
  • 在用户执行 case: <- ctx.Done() 函数时会惰性创建 chan；
  • 当该上下文主动取消、超时或到截止时间时，该 chan 会关闭，通道的关闭可能会异步发生；
  • 如果此上下文永远无法取消，则可能会返回 nil，连续调用返回相同的值；
  • 通过监听该 chan 是否关闭来判断该上下文是否取消，示例如下:

    // Stream 使用 DoSomething 生成值并将它们发送到 out，直到 DoSomething 返回错误或 ctx.Done() 是关闭的
    func Stream(ctx context.Context, out chan<- Value) error {
    	for {
    		v, err := DoSomething(ctx)
    		if err != nil {
    			return err
    		}
    		select {
    		case <-ctx.Done():
    			return ctx.Err()
    		case out <- v:
    		}
    	}
    }
    

• Err 可以表示 Done 返回的 chan 是否已经关闭，以及关闭的原因：
  • 如果 chan 未关闭，则 Err 返回 nil；
  • 如果 chan 已关闭，则 Err 将返回一个非 nil 错误；
  • 如果是因为上下文取消关闭的，则为"Canceled"；
  • 如果是因为上下文的截止时间已过，则为"DeadlineExceeded"；
  • 在 Err 返回非 nil 错误后，对 Err 的连续调用将返回相同的错误；
• Value 返回与此上下文关联的键值：
  • 如果没有值与键关联，则返回 nil；
  • 具有相同键的连续调用 Value 将返回相同的结果；
  • 仅对传输进程和 API 边界的请求范围数据使用上下文值，而不对将可选参数传递给函数使用上下文值；
  • 键标识上下文中的特定值，希望在上下文中存储值的函数通常在全局变量中分配一个键，然后将该键用作 context.WithValue 和 context.Value 的参数；
  • 键可以是任何支持相等的类型，包应将键定义为未导出的类型以避免冲突，定义上下文键的包应为使用该键存储的值提供类型安全的访问器，示例如下：

    // Package 包 user 定义了一个 User 类型用于在上下文中存储
    package user
    
    import "context"
    
    // User 是存储在上下文中的值的类型
    type User struct {...}
    
    // key 是定义在这个包中未导出的类型，这样可以防止与其他包中定义的 key 发生冲突
    type key int
    
    // userKey 是存储在上下文中 user.User 类型的值，是非导出的，用户不能直接使用，需要用下面的函数创建
    var userKey key
    
    // NewContext 返回一个值为 u 的新 Context
    func NewContext(ctx context.Context, u *User) context.Context {
    	return context.WithValue(ctx, userKey, u)
    }
    
    // FromContext 返回一个类型为 User 存储在 ctx 中的值，如果有的话
    func FromContext(ctx context.Context) (*User, bool) {
    	u, ok := ctx.Value(userKey).(*User)
    	return u, ok
    }
    

2，emptyCtx

// Canceled 上下文取消的错误，当上下文取消时，在调用Context.Err()函数时返回
var Canceled = errors.New("context canceled")
// DeadlineExceeded 上下文过期的错误，当上下文过期时，在调用Context.Err()函数时返回
var DeadlineExceeded error = deadlineExceededError{}

// 实现了 net.Error 接口，能用于网络请求的上下文
type deadlineExceededError struct{}
func (deadlineExceededError) Error() string   { return "context deadline exceeded" }
func (deadlineExceededError) Timeout() bool   { return true } // Is the error a timeout?
func (deadlineExceededError) Temporary() bool { return true } // Is the error temporary?

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
}
func (e *emptyCtx) String() string {
	switch e {
	case background:
		return "context.Background"
	case todo:
		return "context.TODO"
	}
	return "unknown empty Context"
}

var (
	background = new(emptyCtx)
	todo       = new(emptyCtx)
)
// Background 它通常由 main 函数、初始化和测试使用，并用作传入请求的顶级上下文。
func Background() Context {
	// 返回一个非 nil 的空上下文。它永远不会被取消，没有值，也没有截止日期。
	return background
}
// TODO 当不清楚要使用哪个上下文或尚不可用时（因为周围的函数尚未扩展为接受上下文参数），则执行 TODO。
func TODO() Context {
	// 返回一个非 nil 的空上下文。代码应使用上下文。
	return todo
}

• emptyCtx一个空的上下文类型，实现了Context的接口，emptyCtx 永远不会取消，没有值，也没有截止日期；
• Background和TODO，返回一个非 nil 的空上下文，即 emptyCtx 的指针类型；
• Canceled和DeadlineExceeded分别是上下文取消和到期的错误，其中DeadlineExceeded变量类型还实现了net.Error接口，能用于网络请求的上下文；

3，cancelCtx

type canceler interface {
	cancel(removeFromParent bool, err error)
	Done() <-chan struct{}
}

var closedchan = make(chan struct{})
func init() {
	close(closedchan) // todo import, closed the chain at init
}

type cancelCtx struct {
	Context

	mu       sync.Mutex            // 保护下述字段
	done     atomic.Value          // 原子类型的值，存储了空结构体 chan ，懒惰式被创建，该取消函数第一次被调用时关闭它
	children map[canceler]struct{} // 存储实现了 canceler 接口的子上下文，该取消函数第一次被调用时置为 nil
	err      error                 // 该取消函数第一次被调用时设置为非空的错误
}

var cancelCtxKey int // cancelCtx 为自身返回的 key

func (c *cancelCtx) Value(key interface{}) interface{} {
	// 用于判断父上下文对应的对象是否为自己，即是可取消的上下文，取地址的方式判断
	if key == &cancelCtxKey {
		return c
	}
	return c.Context.Value(key)
}

// 该取消函数会关闭 c 中 done  chan ，递归取消所有的子上下文，如果 removeFromParent 为真，则将 c 从父上下文中移除
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
	if err == nil { // 从被执行的地方传入一个不为空的err，有可能是父上下文的err，有可能是DeadlineExceeded、Canceled
		panic("context: internal error: missing cancel error")
	}
	c.mu.Lock()
	if c.err != nil { // 该上下文的err不为空，说明已经被其他协程执行过取消函数了
		c.mu.Unlock()
		return // already canceled
	}
	c.err = err
	d, _ := c.done.Load().(chan struct{})
	// 关闭该上下文中的 chan ，通知其他协程
	if d == nil {
		// 表示 Done 函数没有没调用过，给 d 存储一个关闭的 chan 
		c.done.Store(closedchan)
	} else {
		close(d)
	}
	for child := range c.children {
		// 遍历所有子上下文，并递归执行子函数的取消函数
		child.cancel(false, err)
	}
	c.children = nil
	c.mu.Unlock()

	if removeFromParent { // 从父上下文中移除自己
		removeChild(c.Context, c)
	}
}

// Done 函数返回的是一个只读的 chan，而且没有地方向这个 chan 里面写数据。
// 所以，直接调用读这个 chan，协程会被 block 住。一般通过搭配 select 来使用。一旦关闭，就会立即读出零值。
func (c *cancelCtx) Done() <-chan struct{} {
	d := c.done.Load() // c.done 是否有值，有则直接断言后返回
	if d != nil {
		return d.(chan struct{})
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	d = c.done.Load()
	if d == nil { // “懒汉式”创建，只有调用了 Done() 方法的时候才会被创建
		d = make(chan struct{})
		c.done.Store(d)
	}
	return d.(chan struct{})
}

func (c *cancelCtx) Err() error {
	c.mu.Lock()
	err := c.err
	c.mu.Unlock()
	return err
}

type stringer interface {
	String() string
}
func contextName(c Context) string {
	if s, ok := c.(stringer); ok {
		return s.String()
	}
	return reflectlite.TypeOf(c).String()
}
// 获取上下文的名字
func (c *cancelCtx) String() string {
	return contextName(c.Context) + ".WithCancel"
}

• canceler 是一个声明了 cancel 和 Done 函数的接口类型，能够直接取消上下文，由 cancelCtx 和 timerCtx 结构实现；
• closedchan 是一个可复用的关闭通道，在 context 包初始化的时候关闭；
• cancelCtx 是一个可以执行取消操作的上下文结构，继承了 Context 接口，同时实现了 cancelCtx 接口，当被取消后，它也能取消所有实现了 canceler 的子上下文；
  • done 字段，以原子的方式存储了一个空结构体 chan ，当执行取消操作时该字段存储的 chan 被关闭或是被替换为关闭的 chan ，即 closedchan；
  • children 字段，存储实现了 canceler 接口的子上下文，该取消函数第一次被调用时置为 nil；
  • Value 方法，重载了 Context 接口中的 Value 方法，通过 key 获取 value，如果 key 是 cancelCtxKey 则返回自身，否则调用 Context 接口的 Value 方法；
  • cancel 方法，将 done 字段中存储的 chan 关闭，如果没有存储 chan 则重新存储一个关闭的 chan ；遍历 children 字段中存储的所有子上下文，并递归执行子上下文的取消函数，并将 children 置为 nil，即删除所有的子上下文；以及选择是否从自己的父上下文（实现了canceler接口的上下文）中的 children 字段中删除自己；
  • Done 方法，返回 done 字段中存储的 chan ，如果 done 中没有则直接创建并返回，所以 done 中 chan 只有在第一次调用 Done 方法时才会被创建；返回的 chan 是只读的，且没有 goroutine 往里面写数据，当其他 goroutine 直接读取该 chan 时会被 block 住，一般通过搭配 select 来使用，一旦关闭（cancel 方法被调用时），就会立即读出零值；

4，WithCancel

type CancelFunc func()

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
	if parent == nil {
		panic("cannot create context from nil parent")
	}
	c := newCancelCtx(parent)
	propagateCancel(parent, &c)                    // 将自己挂载到 parent，当 parent 取消或 chan 被关闭时，能自动或手动关闭自己
	return &c, func() { c.cancel(true, Canceled) } // 该取消函数被执行时，一定返回了不为空的error
}

// newCancelCtx 返回一个初始化后的取消上下文
func newCancelCtx(parent Context) cancelCtx {
	return cancelCtx{Context: parent}
}

// goroutines 记录已经创建的 goroutine 的数量，用于测试
var goroutines int32

// propagateCancel 传播取消，安排父上下文被取消时，子上下文也被取消
func propagateCancel(parent Context, child canceler) {
	done := parent.Done()
	if done == nil { // 父节点为空，直接返回
		return
	}

	select {
	case <-done:
		// 该 chan 为只读，只有关闭后才会触发该条件，读到零值
		// 如果遍历子节点的时候，调用 child.cancel 函数传了 true，还会造成同时遍历和删除一个 map 的境地，会有问题的。
		// 自己会被父节点删除，并置为nil，自己的子节点会自动和自己断绝关系，没必要再传入true
		child.cancel(false, parent.Err()) // 表示父上下文已经取消，直接取消子上下文
		return
	default:
	}

	// 判断 parent 是否为可以取消的 context
	if p, ok := parentCancelCtx(parent); ok {
		// parent 是可以取消的
		p.mu.Lock()
		if p.err != nil { // 父上下文已经取消
			child.cancel(false, p.err) // 表示父上下文已经取消，直接取消子上下文
		} else {
			if p.children == nil {
				p.children = make(map[canceler]struct{})
			}
			// todo important，父节点未取消，将自己挂载到父节点上，才能在父上下文取消的时候自动取消自己
			p.children[child] = struct{}{}
		}
		p.mu.Unlock()
	} else {
		// parent 是不可以取消的
		// 此时 child 无法挂载到 parent，parent 取消时，无法自动取消child
		atomic.AddInt32(&goroutines, +1)
		go func() {
			// 同时监听 parent 和 child，监听到parent关闭时手动关闭child，监听到child被其他协程关闭时退出
			select {
			case <-parent.Done(): // 监视父上下文的 chan 是否关闭，关闭则取消子上下文并退出
				child.cancel(false, parent.Err())
			case <-child.Done(): // 监视子上下文的 chan 是否关闭，关闭则退出。若没有此条件，parent上下文也没关闭，则会一直阻塞
			}
		}()
	}
}

// parentCancelCtx 判断 parent 对象是否为可以取消的上下文，并返回该可取消的上下文 *cancelCtx，
func parentCancelCtx(parent Context) (*cancelCtx, bool) {
	done := parent.Done()
	if done == closedchan || done == nil {
		return nil, false
	}
	// 通过 parent.Value(&cancelCtxKey) 找到里面封装的 *cancelCtx 并检查 parent.Done() 是否匹配 *cancelCtx
	p, ok := parent.Value(&cancelCtxKey).(*cancelCtx)
	if !ok { // 判断是否为可以断言为可以取消的上下文
		return nil, false
	}
	// 判断断言前后是否是同一个done
	pdone, _ := p.done.Load().(chan struct{})
	if pdone != done { // 判断可取消的上下文中的 done 值断言的 chan 
		return nil, false
	}
	return p, true
}

// removeChild 从父上下文中移除子上下文
func removeChild(parent Context, child canceler) {
	// 判断 parent 是否为可以取消的上下文，只有 cancelCtx 才有子上下文
	p, ok := parentCancelCtx(parent)
	if !ok {
		return
	}
	p.mu.Lock()
	if p.children != nil { // 从父上下文的map中移除自己
		delete(p.children, child)
	}
	p.mu.Unlock()
}

• CancelFunc 一个函数类型，表示取消函数的具体执行内容，告诉操作者放弃其工作，不会等待工作停止，能够被多个协程同时调用，当第一次被调用后，后续的调用不会做任何事情；
• WithCancel 返回一个基于 parent 上下文创建的可以取消的子上下文和一个取消函数，即 cancelCtx 对象和包含cancel 方法的函数；
  • 当返回的取消函数被调用时，或 parent 中的 Done 返回的 chan 被关闭时，返回的子上下文中 Done 返回的 chan 也会关闭，以先发生者为准；
  • 取消此上下文会释放与其关联的资源，因此代码应在此上下文中运行的操作完成后立即调用 cancel；
• propagateCancel 传播取消操作，父上下文被取消时，子上下文也被取消；
  • 先监听 parent 中的 chan ，如果已经关闭了，则直接调用 child 的取消方法，取消 child 及其所有的子上下文；
  • 如果没有关闭，parent 是否是可以取消的上下文，即是否是 cancelCtx 类型的对象：
    • 如果是，且已经执行过取消方法，则直接调用 child 的取消方法，取消 child 及其所有的子上下文；
    • 如果是，且没有执行过取消方法，则将 child 存入到其 children 字段的map中，即将 child 挂在到 parent 上；
    • 如果不是，此时 child 无法挂载到 parent，parent 取消时无法自动取消 child，需要同时监听 parent 和 child 的 chan ，监听到 parent 的 chan 关闭时手动取消 child，监听到 child 的 chan 被其他 goroutine 关闭时则直接退出；

5，timerCtx

// timerCtx 带有计时器和截止日期，它嵌入了一个 cancelCtx 来实现 Done 和 Err。
// 它通过停止其计时器然后委托给 cancelCtx.cancel 来实现取消。
type timerCtx struct {
	cancelCtx
	timer    *time.Timer // timer 会在 deadline 到来时，自动取消 context
	deadline time.Time
}

// Deadline 返回 timerCtx 的截止时间
func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
	return c.deadline, true
}

// 返回 timerCtx 上下文的名字
func (c *timerCtx) String() string {
	return contextName(c.cancelCtx.Context) + ".WithDeadline(" +
		c.deadline.String() + " [" +
		time.Until(c.deadline).String() + "])"
}

func (c *timerCtx) cancel(removeFromParent bool, err error) {
	c.cancelCtx.cancel(false, err) // 执行 cancelCtx 的取消函数
	if removeFromParent {
		// 从其父级 cancelCtx 的子级中删除此计时器
		removeChild(c.cancelCtx.Context, c)
	}
	c.mu.Lock()
	if c.timer != nil {
		c.timer.Stop() // 停止计时
		c.timer = nil
	}
	c.mu.Unlock()
}

• timerCtx 是一个带计时器上下文的结构，继承了 cancelCtx 结构，即实现了 cancelCtx 接口，同时还能设置截止时间，所以该计时器上下文类型不仅能够主动执行取消操作还能到达截止时间后自动执行取消操作；
• timer 存储了一个计时器，即到截止时间后执行取消函数，deadline 存储截止时间；
• Deadline 是重载后的方法，返回 timerCtx 的截止时间；
• cancel 是重载后的方法，该取消操作被执行后，先执行父上下文 cancelCtx 的取消方法，从其父上下文 cancelCtx 的子上下文(children)中删除此计时器上下文，计时器不为空时停止计时器；

6，WithDeadline

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
	if parent == nil {
		panic("cannot create context from nil parent")
	}
	// 判断父上下文是否设置了截止时间，以及截止时间是否早于当前设置的截止时间
	if cur, ok := parent.Deadline(); ok && cur.Before(d) {
		// 父上下文设置的截止时间更早，则直接从父上下文中创建，用的是父上下文的截止时间
		return WithCancel(parent)
	}
	// 父上下文设置的截止时间要晚一些，重新从父上下文中创建，并设置自己的截止时间
	c := &timerCtx{
		cancelCtx: newCancelCtx(parent),
		deadline:  d,
	}
	// 将自己挂载到 parent，当 parent 取消或 chan 被关闭时，能自动或手动关闭自己
	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 { // 表示该上线文还没有被取消
		c.timer = time.AfterFunc(dur, func() { // 为计时器创建一个执行函数，即时间到期后执行该取消函数
			c.cancel(true, DeadlineExceeded)
		})
	}
	return c, func() { c.cancel(true, Canceled) }
}

• WithDeadline 返回父上下文的副本，即一个带计时器的上下文，并将截止日期调整为不晚于 d；
• 父上下文设置的截止时间更早，则直接通过 WithCancel 从父上下文中创建一个可取消的上下文，截止时间依赖父上下文的截止时间；
• 父上下文设置的截止时间要晚或是没有设置截止时间，则重新从父上下文中创建一个可取消的上下文，并设置自己的时间为截止时间，然后将自己挂载到 parent 上，当 parent 取消或 chan 被关闭时，能自动或手动关闭自己；
• 当截止时间未到期且该上下文还未被主动取消时，根据截止时间创建一个计时器，并设置计时器到时候自动执行取消函数；
• 当截止时间到期、当返回的取消函数被调用时，或 parent 中的 Done 返回的 chan 被关闭时，返回的子上下文中 Done 返回的 chan 也会关闭，以先发生者为准；
• 取消此上下文会释放与其关联的资源，因此代码应在此上下文中运行的操作完成后立即调用 cancel；

7，WithTimeout

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
	return WithDeadline(parent, time.Now().Add(timeout))
}

• WithTimeout 对 WithDeadline 进行了一层封装，当前时间加上超时时间即为截止时间；

8，WithValue

• valueCtx 是一个可以存储键值对的上下文结构，继承了 Context 接口；
  • 该上下文结构体重载了 Value 方法，会顺着链路一直往上找，比较当前节点的 key 是否是要找的 key，如果是则直接返回 value；
  • 否则一直顺着 context 往上，最终找到根节点（一般是 emptyCtx），直接返回一个 nil，所以用 Value 方法的时候要判断结果是否为 nil；
• WithValue 返回父上下文的副本，即一个可以存储键值对的上下文，其中与 key 关联的值为 val；
• 仅对传输进程和 API 的请求范围的数据使用上下文值，而不对将可选参数传递给函数；
• 提供的 key 必须是可比的，用户应定义自己的键类型，并且不应是字符串类型或任何其他内置类型，以避免使用上下文的包之间发生冲突；

func WithValue(parent Context, key, val interface{}) Context {
	if parent == nil {
		panic("cannot create context from nil parent")
	}
	if key == nil {
		panic("nil key")
	}
	if !reflectlite.TypeOf(key).Comparable() { // key 是需要可以比较的类型
		panic("key is not comparable")
	}
	return &valueCtx{parent, key, val}
}

// valueCtx 携带一个键值对，它实现该键的值，并将所有其他调用委托给嵌入式上下文，key 是需要可以比较的类型
type valueCtx struct {
	Context
	key, val interface{}
}

// stringify 尝试在不使用 fmt 的情况下对 V 进行字符串化，因为我们不希望上下文依赖于 Unicode 表。这仅由 valueCtx.String（） 使用。
func stringify(v interface{}) string {
	switch s := v.(type) {
	case stringer:
		return s.String()
	case string:
		return s
	}
	return "<not Stringer>"
}
func (c *valueCtx) String() string {
	return contextName(c.Context) + ".WithValue(type " +
		reflectlite.TypeOf(c.key).String() +
		", val " + stringify(c.val) + ")"
}

func (c *valueCtx) Value(key interface{}) interface{} {
	if c.key == key {
		return c.val
	}
	return c.Context.Value(key)
}

9，各上下文结构之间的关系