Context

参考

Golang context 实现原理

go 之 Context 基本使用

前言

context 是 golang 中的经典工具

• 主要在异步场景中用于实现并发协调以及对 goroutine 的生命周期控制.
• 除此之外，context 还兼有一定的数据存储能力.
• 本着知其然知其所以然的精神，本文和大家一起深入 context 源码一探究竟，较为细节地对其实现原理进行梳理.

为啥使用 Context

比如以下这个例子，一旦主协程关闭done channel，那么子协程就可以退出了，这样就实现了主协程通知子协程的需求

  
func main() {
    // 数据通道
    messages := make(chan int, 10)
    // 信号通道
    done := make(chan bool)

    defer close(messages)
    // consumer
    go func() {
        // 每隔一秒执行一次，定时器
        ticker := time.NewTicker(1 * time.Second)
        for _ = range ticker.C {
            select {
            // 若关闭了通道则 执行下面的代码
            case <-done:
                fmt.Println("child process interrupt...")
                return
            default:
                fmt.Printf("send message: %d\n", <-messages)
            }
        }
    }()

    // producer
    for i := 0; i < 10; i++ {
        messages <- i
    }
    time.Sleep(5 * time.Second)
    // 关闭通道, 退出上面的匿名函数
    close(done)
    time.Sleep(1 * time.Second)
    fmt.Println("main process exit!")
}

假如主协程中有多个任务1, 2, …m，主协程对这些任务有超时控制。如果还是使用done channel的用法 ，那么使用done channel的方式将会变得非常繁琐且混乱

我们需要一种优雅的方案来实现这样一种机制：

• 上层任务取消后，所有的下层任务都会被取消；
• 中间某一层的任务取消后，只会将当前任务的下层任务取消，而不会影响上层的任务以及同级任务。

这个时候context就派上用场了

Context 的使用

注意: 这两种方式是创建根context，不具备任何功能，需要用到with系列函数来实现具体功能`

根 Context

• context.Backgroud()
  • 是上下文的默认值，所有其他的上下文都应该从它衍生（Derived）出来, ,一般情况下我们用这个
• context.TODO()
  •  应该只在不确定应该使用哪种上下文时使用；

With 系列函数

 context.withCancel() 取消控制

就可以使用withCancel来衍生一个context传递到不同的goroutine中，当我想让这些goroutine停止运行，就可以调用cancel来进行取消

// 案例一

/*  
	代码逻辑:
    我们使用withCancel创建一个基于Background的ctx，然后启动一个讲话程序，
    每隔1s说一话，main函数在10s后执行cancel，那么speak检测到取消信号就会退出。
*/

package main

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

// context.Background()函数创建根上下文，返回父context和cancel函数
func NewWithCancel() (context.Context, context.CancelFunc) {
	return context.WithCancel(context.Background())

}

//  业务逻辑
func Speak(ctx context.Context) {
	for range time.Tick(time.Second) {
		select {
		case <-ctx.Done():
			fmt.Println("关闭线程...")
			fmt.Println(ctx.Err())
		default:
			fmt.Println("hahahhaa")
		}
	}
}

func main() {
        // 创建父context和cancel函数
	ctx, cancel := NewWithCancel()

        // 使用协程来启动业务逻辑
	go Speak(ctx)

	time.Sleep(10 * time.Second)

        // 取消的信号，结束Speak函数的运行
	cancel()

	time.Sleep(1 * time.Second)

}

  
// 案例二

/*
代码逻辑: 
1. 利用根Context创建一个父Context，使用父Context创建一个协程，
2. 利用上面的父Context再创建一个子Context，使用该子Context创建一个协程
3. 一段时间后，调用父Context的cancel函数，会发现父Context的协程和子Context的协程都收到了信号，被结束了

*/
package main
 
import (
	"context"
	"fmt"
	"time"
)
 
func main() {
	// 父context(利用根context得到)
	ctx, cancel := context.WithCancel(context.Background())
 
	// 父context的子协程
	go watch1(ctx)
 
	// 子context，注意：这里虽然也返回了cancel的函数对象，但是未使用
	valueCtx, _ := context.WithCancel(ctx)
	// 子context的子协程
	go watch2(valueCtx)
 
	fmt.Println("现在开始等待3秒,time=", time.Now().Unix())
	time.Sleep(3 * time.Second)
 
	// 调用cancel()
	fmt.Println("等待3秒结束,调用cancel()函数")
	cancel()
 
	// 再等待5秒看输出，可以发现父context的子协程和子context的子协程都会被结束掉
	time.Sleep(5 * time.Second)
	fmt.Println("最终结束,time=", time.Now().Unix())
}
 
// 父context的协程
func watch1(ctx context.Context) {
	for {
		select {
		case <-ctx.Done(): //取出值即说明是结束信号
			fmt.Println("收到信号，父context的协程退出,time=", time.Now().Unix())
			return
		default:
			fmt.Println("父context的协程监控中,time=", time.Now().Unix())
			time.Sleep(1 * time.Second)
		}
	}
}
 
// 子context的协程
func watch2(ctx context.Context) {
	for {
		select {
		case <-ctx.Done(): //取出值即说明是结束信号
			fmt.Println("收到信号，子context的协程退出,time=", time.Now().Unix())
			return
		default:
			fmt.Println("子context的协程监控中,time=", time.Now().Unix())
			time.Sleep(1 * time.Second)
		}
	}
}

context.WithTimeout 超时控制

withTimeout或者withDeadline来做超时控制，当一次请求到达我们设置的超时时间，就会及时取消，不在往下执行。withTimeout和withDeadline作用是一样的，就是传递的时间参数不同而已，他们都会通过传入的时间来自动取消Context，这里要注意的是他们都会返回一个cancelFunc方法，通过调用这个方法可以达到提前进行取消

  
// 案例一

package main

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

// 创建一个带超时context， 三秒后退出执行
func NewContextWithTimeout() (context.Context, context.CancelFunc) {
	return context.WithTimeout(context.Background(), 3*time.Second)
}

// 处理程序
func HttpHandler() {
	ctx, cancel := NewContextWithTimeout()
	defer cancel()
	deal(ctx)

}

// 业务逻辑代码
func deal(ctx context.Context) {
	for i := 0; i < 10; i++ {
		time.Sleep(1 * time.Second)
		select {
		case <-ctx.Done():
			fmt.Println(ctx.Err())
			return
		default:
			fmt.Printf("deal time is %d\n", i)
		}
	}
}
func main() {
	HttpHandler()
}

// 案例二

package main
 
import (
	"context"
	"fmt"
	"time"
)
 
func main() {
	// 创建一个子节点的context,3秒后自动超时
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
 
	go watch(ctx, "监控1")
	go watch(ctx, "监控2")
 
	fmt.Println("现在开始等待8秒,time=", time.Now().Unix())
	time.Sleep(8 * time.Second)
 
	fmt.Println("等待8秒结束,准备调用cancel()函数，发现两个子协程已经结束了，time=", time.Now().Unix())
	cancel()
}
 
// 单独的监控协程
func watch(ctx context.Context, name string) {
	for {
		select {
		case <-ctx.Done():
			fmt.Println(name, "收到信号，监控退出,time=", time.Now().Unix())
			return
		default:
			fmt.Println(name, "goroutine监控中,time=", time.Now().Unix())
			time.Sleep(1 * time.Second)
		}
	}
}

context.WithValue() 携带数据 [谨慎使用]

日常在业务开发中都希望能有一个trace_id能串联所有的日志，这就需要我们打印日志时能够获取到这个trace_id，在python中我们可以用gevent.local来传递，在java中我们可以用ThreadLocal来传递，在Go语言中我们就可以使用Context来传递，通过使用WithValue来创建一个携带trace_id的context，然后不断透传下去，打印日志时输出即可

/*
我们基于context.Background创建一个携带trace_id的ctx，然后通过context树一起传递，
从中派生的任何context都会获取此值，我们最后打印日志的时候就可以从ctx中取值输出到日志中。
目前一些RPC框架都是支持了Context，所以trace_id的向下传递就更方便了
*/
package main

import (
	"context"
	"fmt"
	"strings"
	"time"

	"github.com/google/uuid"
)

type MyKEY string

const (
	KEY MyKEY = "trace_id"
)

// 返回一个UUID
func NewRequestID1() MyKEY {
	return MyKEY(strings.Replace(uuid.New().String(), "-", "", -1))

}

// 创建一个携带trace_id 的ctx
func NewContextWithTraceID() context.Context {
	ctx := context.WithValue(context.Background(), KEY, NewRequestID1())
	return ctx
}

// 打印值
func PrintLog(ctx context.Context, message string) {
	fmt.Printf("%s|info|trace_id=%s|%s", time.Now().Format("2006-01-02 15:04:05"), GetContextValue1(ctx, KEY), message)
}

// 获取设置的key对应的值,并断言
func GetContextValue1(ctx context.Context, k MyKEY) MyKEY {
	v, ok := ctx.Value(k).(MyKEY)
	fmt.Println("打印k:" + k)
	fmt.Printf("打印v: %v\n", v)
	if !ok {
		return ""
	}
	return v
}

func ProcessEnter(ctx context.Context) {
	PrintLog(ctx, "Golang")
}

func main() {
	ProcessEnter(NewContextWithTraceID())
}

• 不建议使用 context 值传递关键参数，关键参数应该显示的声明出来
• 因为携带value也是key value，避免context多个包使用带来的冲突,建议使用内置类型
• context 传递的数据 key value 都是 interface，所以类型断言时别忘了保证程序的健壮性

应用场景

• RPC调用

• PipeLine

• 超时请求

• `HTTP服务器的request互相传递数据

注意：

1. 不要将 Context 塞到结构体里。直接将 Context 类型作为函数的第一参数，而且一般都命名为 ctx。
2. 不要向函数传入一个 nil 的 context，如果你实在不知道传什么，标准库给你准备好了一个 context：todo。
3. 不要把本应该作为函数参数的类型塞到 context 中，context 存储的应该是一些共同的数据。例如：登陆的 session、cookie 等。
4. 同一个 context 可能会被传递到多个 goroutine，别担心，context 是并发安全的

核心数据结构

context.Context

context数据结构

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

Context 为 interface，定义了四个核心 api：

• Deadline：返回 context 的过期时间；也就是完成工作的截止日期；如果没有设定期限，将返回ok == false

• Done：返回 context 中的 channel；当绑定当前context的任务被取消时，将返回一个关闭的channel；如果当前context不会被取消，将返回nil

• Err：返回错误；

  • 如果 Done 返回的 channel 没有关闭，将返回 nil;如果 Done 返回的 channel 已经关闭，将返回非空的值表示任务结束的原因
  • 如果是 context 被取消，Err 将返回 Canceled；如果是 context 超时，Err 将返回 DeadlineExceeded Err() error

• Value：返回 context 中的对应 key 的值.

标准 error

var Canceled = errors.New("context canceled")

var DeadlineExceeded error = deadlineExceededError{}

type deadlineExceededError struct{}

func (deadlineExceededError) Error() string   { return "context deadline exceeded" }
func (deadlineExceededError) Timeout() bool   { return true }
func (deadlineExceededError) Temporary() bool { return true

• • Canceled：context 被 cancel 时会报此错误；

• • DeadlineExceeded：context 超时时会报此错误.

emptyCtx

类的实现

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 any) any {
    return 
}

• emptyCtx 是一个空的 context，本质上类型为一个整型；

• Deadline 方法会返回一个公元元年时间以及 false 的 flag，标识当前 context 不存在过期时间；

• Done 方法返回一个 nil 值，用户无论往 nil 中写入或者读取数据，均会陷入阻塞；

• Err 方法返回的错误永远为 nil；

•  Value 方法返回的 value 同样永远为 nil.

context.Background() & context.TODO()

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

func Background() Context {
    return background
}

func TODO() Context {
    return todo
}

我们所常用的 context.Background() 和 context.TODO() 方法返回的均是 emptyCtx 类型的一个实例.

cancelCtx

cancelCtx 数据结构

cancelCtx数据结构

type cancelCtx struct {
    Context
   
    mu       sync.Mutex            // protects following fields
    done     atomic.Value          // of chan struct{}, created lazily, closed by first cancel call
    children map[canceler]struct{} // set to nil by the first cancel call
    err      error                 // set to non-nil by the first cancel call
}

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

• embed 了一个 context 作为其父 context. 可见，cancelCtx 必然为某个 context 的子 context；

• Mu 内置了一把锁，用以协调并发场景下的资源获取；

• done：实际类型为 chan struct{}，即用以反映 cancelCtx 生命周期的通道；c.done 是“懒汉式”创建，只有调用了 Done() 方法的时候才会被创建。再次说明，函数返回的是一个只读的 channel，而且没有地方向这个 channel 里面写数据。所以，直接调用读这个 channel，协程会被 block 住。一般通过搭配 select 来使用。一旦关闭，就会立即读出零值。

• children：一个 set，指向 cancelCtx 的所有子 context；

• err：记录了当前 cancelCtx 的错误. 必然为某个 context 的子 context；

Deadline 方法

cancelCtx 未实现该方法，仅是 embed 了一个带有 Deadline 方法的 Context interface，因此倘若直接调用会报错.

Done 方法

cancelCtx.Done

.done 是“懒汉式”创建**，只有调用了 Done () 方法的时候才会被创建。再次说明，函数返回的是一个只读的 channel，而且没有地方向这个 channel 里面写数据。所以，直接调用读这个 channel，协程会被 block 住。一般通过搭配 select 来使用。

func (c *cancelCtx) Done() <-chan struct{} {
    d := c.done.Load()
    if d != nil {
        return d.(chan struct{})
    }
    c.mu.Lock()
    defer c.mu.Unlock()
    d = c.done.Load()
    if d == nil {
        d = make(chan struct{})
        c.done.Store(d)
    }
    return d.(chan struct{})
}

• 基于 atomic 包，读取 cancelCtx 中的 chan；倘若已存在，则直接返回；

• 加锁后，在此检查 chan 是否存在，若存在则返回；（double check）

• 初始化 chan 存储到 aotmic.Value 当中，并返回.（懒加载机制）

Err 方法

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

• • 加锁；

• • 读取 cancelCtx.err；

• • 解锁；

• • 返回结果.

Value 方法

func (c *cancelCtx) Value(key any) any {
    if key == &cancelCtxKey {
        return c
    }
    return value(c.Context, key)
}

• • 倘若 key 特定值 &cancelCtxKey，则返回 cancelCtx 自身的指针；

• • 否则遵循 valueCtx 的思路取值返回

context.WithCancel()

context.WithCancel()

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
    if parent == nil {
        panic("cannot create context from nil parent")
    }
    c := newCancelCtx(parent)
    propagateCancel(parent, &c)
    return &c, func() { c.cancel(true, Canceled) }
}

func newCancelCtx(parent Context) cancelCtx {
    return cancelCtx{Context: parent}
}

• • 校验父 context 非空；

• • 注入父 context 构造好一个新的 cancelCtx；

• • 在 propagateCancel 方法内启动一个守护协程，以保证父 context 终止时，该 cancelCtx 也会被终止；

• • 将 cancelCtx 返回，连带返回一个用以终止该 cancelCtx 的闭包函数.

这是一个暴露给用户的方法，传入一个父 Context（这通常是一个 background，作为根节点），返回新建的 context，新 context 的 done channel 是新建的（前文讲过）。

当 WithCancel 函数返回的 CancelFunc 被调用或者是父节点的 done channel 被关闭（父节点的 CancelFunc 被调用），此 context（子节点） 的 done channel 也会被关闭。

注意传给 WithCancel 方法的参数，前者是 true，也就是说取消的时候，需要将自己从父节点里删除。第二个参数则是一个固定的取消错误类型：

propagateCancel

这个方法的作用就是向上寻找可以“挂靠”的“可取消”的 context，并且“挂靠”上去。这样，调用上层 cancel 方法的时候，由上层的协程来管理对子 context 的取消。如果没有父 context ，就自己新建一个携程

propagate流程

func propagateCancel(parent Context, child canceler) {
	// 父节点是个空节点
	if parent.Done() == nil {
		return // parent is never canceled
	}
	// 找到可以取消的父 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{})
			}
			// "挂到"父节点上
			p.children[child] = struct{}{}
		}
		p.mu.Unlock()
	} else {
		// 如果没有找到可取消的父 context。新启动一个协程监控父节点或子节点取消信号
		go func() {
			select {
			case <-parent.Done():
				child.cancel(false, parent.Err())
			case <-child.Done():
			}
		}()
	}
}

propagateCancel 方法顾名思义，用以传递父子 context 之间的 cancel 事件：

• 倘若 parent 是不会被 cancel 的类型（如 emptyCtx），则直接返回；

•  倘若 parent 已经被 cancel，则直接终止子 context，并以 parent 的 err 作为子 context 的 err；

•  假如 parent 是 cancelCtx 的类型，则加锁，并将子 context 添加到 parent 的 children map 当中；

•  假如 parent 不是 cancelCtx 类型，但又存在 cancel 的能力（比如用户自定义实现的 context），则启动一个协程，通过多路复用的方式监控 parent 状态，倘若其终止，则同时终止子 context，并透传 parent 的 err.

• • 倘若 parent 的 channel 已关闭或者是不会被 cancel 的类型，则返回 false；

• • 倘若以特定的 cancelCtxKey 从 parent 中取值，取得的 value 是 parent 本身，则返回 true. （基于 cancelCtxKey 为 key 取值时返回 cancelCtx 自身，是 cancelCtx 特有的协议）.

cancelCtx.cancel

cancel() 方法的功能就是关闭 channel：c.done；递归地取消它的所有子节点；从父节点从删除自己。达到的效果是通过关闭 channel，将取消信号传递给了它的所有子节点。Goroutine 接收到取消信号的方式就是 select 语句中的 读 c.done 被选中

func (c *cancelCtx) cancel(removeFromParent bool, err error) {
    // 必须要传 err
	if err == nil {
		panic("context: internal error: missing cancel error")
	}
	c.mu.Lock()
	if c.err != nil {
		c.mu.Unlock()
		return // 已经被其他协程取消
	}
	// 给 err 字段赋值
	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)
	}
}

• • cancelCtx.cancel 方法有两个入参，第一个 removeFromParent 是一个 bool 值，表示当前 context 是否需要从父 context 的 children set 中删除；第二个 err 则是 cancel 后需要展示的错误；

• • 进入方法主体，首先校验传入的 err 是否为空，若为空则 panic；

• • 加锁；

• • 校验 cancelCtx 自带的 err 是否已经非空，若非空说明已被 cancel，则解锁返回；

• • 将传入的 err 赋给 cancelCtx.err；

• • 处理 cancelCtx 的 channel，若 channel 此前未初始化，则直接注入一个 closedChan，否则关闭该 channel；

• • 遍历当前 cancelCtx 的 children set，依次将 children context 都进行 cancel；

• • 解锁.

• • 根据传入的 removeFromParent flag 判断是否需要手动把 cancelCtx 从 parent 的 children set 中移除.

走进 removeChild 方法中，观察如何将 cancelCtx 从 parent 的 children set 中移除：

func removeChild(parent Context, child canceler) {
    p, ok := parentCancelCtx(parent)
    if !ok {
        return
    }
    p.mu.Lock()
    if p.children != nil {
        delete(p.children, child)
    }
    p.mu.Unlock()
}

• • 如果 parent 不是 cancelCtx，直接返回（因为只有 cancelCtx 才有 children set） 

• • 加锁；

• • 从 parent 的 children set 中删除对应 child

• • 解锁返回.

timerCtx

类

timerCtx数据结构

type timerCtx struct {
    cancelCtx
    timer *time.Timer // Under cancelCtx.mu.

    deadline time.Time
}

timerCtx 在 cancelCtx 基础上又做了一层封装，除了继承 cancelCtx 的能力之外，新增了一个 time.Timer 用于定时终止 context；另外新增了一个 deadline 字段用于字段 timerCtx 的过期时间.

timerCtx.Deadline()

func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
    return c.deadline, true
}

context.Context interface 下的 Deadline api 仅在 timerCtx 中有效，由于展示其过期时间.

timerCtx.cancel

func (c *timerCtx) cancel(removeFromParent bool, err error) {
    c.cancelCtx.cancel(false, err)
    if removeFromParent {
        removeChild(c.cancelCtx.Context, c)
    }
    c.mu.Lock()
    if c.timer != nil {
        c.timer.Stop()
        c.timer = nil
    }
    c.mu.Unlock()
}

• • 复用继承的 cancelCtx 的 cancel 能力，进行 cancel 处理；

• • 判断是否需要手动从 parent 的 children set 中移除，若是则进行处理

• • 加锁；

• • 停止 time.Timer

• • 解锁返回.

context.WithTimeout & context.WithDeadline

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

context.WithTimeout 方法用于构造一个 timerCtx，本质上会调用 context.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) {
        // The current deadline is already sooner than the new one.
        return WithCancel(parent)
    }
    c := &timerCtx{
        cancelCtx: newCancelCtx(parent),
        deadline:  d,
    }
    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) }
}

• • 校验 parent context 非空；

• • 校验 parent 的过期时间是否早于自己，若是，则构造一个 cancelCtx 返回即可；

• • 构造出一个新的 timerCtx；

• • 启动守护方法，同步 parent 的 cancel 事件到子 context；

• • 判断过期时间是否已到，若是，直接 cancel timerCtx，并返回 DeadlineExceeded 的错误；

• • 加锁；

• • 启动 time.Timer，设定一个延时时间，即达到过期时间后会终止该 timerCtx，并返回 DeadlineExceeded 的错误；

• • 解锁；

• • 返回 timerCtx，已经一个封装了 cancel 逻辑的闭包 cancel 函数.

valueCtx

类

valueCtx数据结构

type valueCtx struct {
    Context
    key, val any
}

• • valueCtx 同样继承了一个 parent context；

• • 一个 valueCtx 中仅有一组 kv 对.

valueCtx.Value()

valueCtx.Value

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

• • 假如当前 valueCtx 的 key 等于用户传入的 key，则直接返回其 value；

• • 假如不等，则从 parent context 中依次向上寻找.

func value(c Context, key any) any {
    for {
        switch ctx := c.(type) {
        case *valueCtx:
            if key == ctx.key {
                return ctx.val
            }
            c = ctx.Context
        case *cancelCtx:
            if key == &cancelCtxKey {
                return c
            }
            c = ctx.Context
        case *timerCtx:
            if key == &cancelCtxKey {
                return &ctx.cancelCtx
            }
            c = ctx.Context
        case *emptyCtx:
            return nil
        default:
            return c.Value(key)
        }
    }
}

• • 启动一个 for 循环，由下而上，由子及父，依次对 key 进行匹配；

• • 其中 cancelCtx、timerCtx、emptyCtx 类型会有特殊的处理方式；

• • 找到匹配的 key，则将该组 value 进行返回.

valueCtx 用法小结

阅读源码可以看出，valueCtx 不适合视为存储介质，存放大量的 kv 数据，原因有三：

• • 一个 valueCtx 实例只能存一个 kv 对，因此 n 个 kv 对会嵌套 n 个 valueCtx，造成空间浪费；

• • 基于 k 寻找 v 的过程是线性的，时间复杂度 O(N)；

• • 不支持基于 k 的去重，相同 k 可能重复存在，并基于起点的不同，返回不同的 v. 由此得知，valueContext 的定位类似于请求头，只适合存放少量作用域较大的全局 meta 数据.

context.WithValue()

func WithValue(parent Context, key, val any) Context {
    if parent == nil {
        panic("cannot create context from nil parent")
    }
    if key == nil {
        panic("nil key")
    }
    if !reflectlite.TypeOf(key).Comparable() {
        panic("key is not comparable")
    }
    return &valueCtx{parent, key, val}
}

• • 倘若 parent context 为空，panic；

• • 倘若 key 为空 panic；

• • 倘若 key 的类型不可比较，panic；

• • 包括 parent context 以及 kv 对，返回一个新的 valueCtx.

通过层层传递 Context ，最终形成这样一棵树：

和链表有点像，只是它的方向相反：Context 指向它的父节点，链表则指向下一个节点。通过 WithValue 函数，可以创建层层的 valueCtx，存储 goroutine 间可以共享的变量。

取值的过程，实际上是一个递归查找的过程：

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

它会顺着链路一直往上找，比较当前节点的 key 是否是要找的 key，如果是，则直接返回 value。否则，一直顺着 context 往前，最终找到根节点（一般是 emptyCtx），直接返回一个 nil。所以用 Value 方法的时候要判断结果是否为 nil。