完整教程：Go语言的context

Golang context 实现原理

本篇文章是基于小徐先生的文章的修改和个人注解，要查看原文可以点击上述的链接查看

目前我这篇文章的go语言版本是1.24.1

context上下文

context被当作第一个参数（官方建议），并且不断的传递下去，基本上一个项目代码到处都是context，但是你们真的知道他有什么作用吗？

接下来就来看看这个golang世界中的典型工具吧

func main()  {    ctx,cancel := context.WithTimeout(context.Background(),10 * time.Second)    defer cancel()    go Monitor(ctx)     time.Sleep(20 * time.Second)} func Monitor(ctx context.Context)  {    for {        fmt.Print("monitor")    }}

但是他到底时如何处理并发控制和实现呢？

接下来就来深入看看他的原理和使用

一.context包介绍

context可以用来在goroutine之间传递上下文信息，相同的context可以传递给运行在不同goroutine中的函数，上下文对于多个goroutine同时使用是安全的，context包定义了上下文类型，可以使用background、TODO创建一个上下文，在函数调用链之间传播context，也可以使用WithDeadline、WithTimeout、WithCancel 或 WithValue 创建的修改副本替换它，听起来有点绕，其实总结起就是一句话：context的作用就是在不同的goroutine之间同步请求特定的数据、取消信号以及处理请求的截止日期。

目前我们常用的一些库都是支持context的，例如gin、database/sql等库都是支持context的，这样更方便我们做并发控制了，只要在服务器入口创建一个context上下文，不断透传下去即可。

二.context的使用

2.1 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 的过期时间

• Done：返回 context 中的 channel

• Err：返回错误

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

2.2 标准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 超时时会报此错误

三.类的实现

3.1 emptyCtx

通过看它的源码我们会发现，这个空的上下文其实就是实现了这个context这个接口，对于实现的4个方法都是返回的nil，这就是为什么说他是empty

在之前的版本中他可能是int类型，后来已经被修改了

type emptyCtx struct{} 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 nil}

• emptyCtx 是一个空的 context

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

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

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

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

3.1.1 context.Background() & context.TODO()

context包主要提供了两种方式创建context：

• context.Backgroud()
• context.TODO()

我们在看代码的时候，经常可以看到不是Background就是todo作为上下文的起始，那他们有什么区别呢？

两者的区别

这两个函数其实只是互为别名，没有差别，官方给的定义是：

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

所以在大多数情况下，我们都使用context.Background作为起始的上下文向下传递。

看一下两者的底层是什么？

两者其实都是一个对context的一个继承

type backgroundCtx struct{ emptyCtx }type todoCtx struct{ emptyCtx } func Background() Context {	return backgroundCtx{}} func TODO() Context {	return todoCtx{}}

看到这里，你会发现上面的两种方式是创建根context，不具备任何功能，具体实践其实还是要依靠context包提供的With系列函数来进行派生：

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)func WithValue(parent Context, key, val interface{}) Context

这四个函数都要基于父Context衍生，通过这些函数，就创建了一颗Context树，树的每个节点都可以有任意多个子节点，节点层级可以有任意多个，画个图表示一下：

基于一个父Context可以随意衍生，其实这就是一个Context树，树的每个节点都可以有任意多个子节点，节点层级可以有任意多个，每个子节点都依赖于其父节点，例如上图，我们可以基于Context.Background衍生出四个子context：ctx1.0-cancel、ctx2.0-deadline、ctx3.0-timeout、ctx4.0-withvalue，这四个子context还可以作为父context继续向下衍生，即使其中ctx1.0-cancel 节点取消了，也不影响其他三个父节点分支。

创建context方法和context的衍生方法就这些，关于这些with函数，会在后续的使用中看到

3.1.2 With类函数

1. WithCancel(parent Context)

用途：创建一个新的上下文和取消函数。当调用取消函数时，所有派生自这个上下文的操作将被通知取消。

应用场景：当一个长时间运行的操作需要能够被取消时。例如，用户在网页中点击“取消”按钮时，相关的数据库或 HTTP 请求应立即停止。

2. WithDeadline(parent Context, d time.Time)

用途：创建一个新的上下文，该上下文在指定的时间点自动取消。

应用场景：在请求处理时设置最大执行时间。例如，调用外部 API 时，如果响应时间超过预期，将自动取消请求，以避免无效的等待。

3. WithTimeout(parent Context, timeout time.Duration)

用途：创建一个新的上下文，它会在指定的持续时间内自动取消。

应用场景：适用于设置操作的超时时间，确保系统不会在某个操作上无休止地等待。常用于网络请求或长时间运行的任务。

4. WithValue(parent Context, key, val interface{})

用途：创建一个新的上下文，并将键值对存储在该上下文中。

应用场景：在处理请求时，将特定的数据（如用户身份信息、RequestID）在处理链中传递，而不需要在每个函数参数中显式传递。

3.2 cancelCtx

接下来看一下第二个实现的类吧，看名字就能看出来他是一个带有取消功能的上下文。

type cancelCtx struct {	Context 	mu       sync.Mutex            	done     atomic.Value          	children map[canceler]struct{} // 这里是一个set{}	err      error                 	cause    error                } type canceler interface {	cancel(removeFromParent bool, err, cause error)	Done() <-chan struct{}} // 这里体现了goland的一个编程哲学// 作为一个父context，它只需要关注子类的这两个方法即可，// 它的子类可能更有能力，但是与父亲无关，只需要知道他是否还存在即可// 会通过就近生成interface的方式，把无关的信息都屏蔽掉。// 也就是谁使用谁声明谁管理

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

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

• done：实际类型为 chan struct{}，即用以反映 cancelCtx 生命周期的通道；

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

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

• cause：是在go1.20之后加入的字段，主要作用适用于记录导致context被取消的具体原因

在这里，要加入一些其他的内容----同步调用和异步调用

同步调用，其实就是一种串行的方式，也就是我们平时写的程序，他是一步一步进行下去，类似一条链的形式。

而异步调用则是开辟协程，并且不会阻塞主线程，并且主线程对子协程的感知能力很弱，开辟了多个子协程，就会形成类似树的形式

就会导致，主线程对子协程的管理能力下降，从而致使协程无法回收，最后导致协程泄露的一个问题。

在创建协程方面，我们要知道一点，如果不知道你创建的协程什么时候结束，你就不应该去创建，不应该滥用并发。

如何解决这个协程的控制呢？

那么今天的主角就是cancelCtx了

先说cancelCtx继承了Context，对其方法进行了一个重写，但是并没有对Deadline方法重写，而是直接继承的父类的。Deadline不进行重写是因为他没有过期取消的能力。

func (c *cancelCtx) Value(key any) any {    // 这里为什么要加入这个判断，在后续会介绍，主要就是用于判断    // 其自身是否是一个cancelCtx类型，这个cancelCtxKey是一个定值	if key == &cancelCtxKey {		return c	}	return value(c.Context, key)} 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{})} func (c *cancelCtx) Err() error {	c.mu.Lock()	err := c.err	c.mu.Unlock()	return err}

3.2.1 WithCancel取消控制

既然想实现这种父子联动的行为，就轮到了With下的一个函数WithCancel函数，通过这个函数从而得到一个cancelCtx对象，从而实现一个对子协程的一个控制

func main()  {    ctx,cancel := context.WithCancel(context.Background())    // 以context.Background()为父，创建得到一个子context和cancel    go Speak(ctx)    time.Sleep(10*time.Second)    cancel()    time.Sleep(1*time.Second)} func Speak(ctx context.Context)  {    for range time.Tick(time.Second){        select {        case <- ctx.Done():            fmt.Println("我要闭嘴了")            return        default:            fmt.Println("balabalabalabala")        }    }}

来对这个例子做出一个解释：

select就相当于是一个多路复用，进行一个监听的操作，通过这个WithCancel获取上下文和取消函数

当调用这个cancel函数的时候，就会直接通过这个ctx.Done发送这个取消机制，从而实现一个控制的效果

这里的操作也就是我们常说的超时控制了，当然cancel并没有涉及到超时，他是通过调用cancel()才可以实现一个关闭。

这个结构体就是cancel取消函数的结构体，他返回的是一个函数类型，所以调用的时候需要加上()

来看下这个函数的具体流程这里先提前告知一点，如果停止一个cancelCtx，则这个它下面所有的子上下文都将被杀死，具体的操作看propagateCancel函数

type CancelFunc func() func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {	c := withCancel(parent)    //Canceled是一个error，自定义的错误信息	return c, func() { c.cancel(true, Canceled, nil) }} func withCancel(parent Context) *cancelCtx {	if parent == nil {		panic("cannot create context from nil parent")	}	c := &cancelCtx{}	c.propagateCancel(parent, c)	return c} func (c *cancelCtx) propagateCancel(parent Context, child canceler) {	c.Context = parent    // 这一步就是说父亲是emptyCtx，他就没有必要取消    // 所以没有必要大费周折的取消它，直接就返回就行	done := parent.Done()	if done == nil {		return // parent is never canceled	}        // 如果父亲被取消了，那儿子也应该直接取消，记录一下取消的错误和原因	select {	case <-done:		// parent is already canceled		child.cancel(false, parent.Err(), Cause(parent))		return	default:	}     // 如果我的父也是cancelCtx，则我需要将孩子加入map里面	if p, ok := parentCancelCtx(parent); ok {		// parent is a *cancelCtx, or derives from one.		p.mu.Lock()		if p.err != nil {			// parent has already been canceled			child.cancel(false, p.err, p.cause)		} else {			if p.children == nil {				p.children = make(map[canceler]struct{})			}			p.children[child] = struct{}{}		}		p.mu.Unlock()		return	}     //检查父Context是否支持AfterFunc，也就是一个回调机制    // 	if a, ok := parent.(afterFuncer); ok {		// parent implements an AfterFunc method.		c.mu.Lock()		stop := a.AfterFunc(func() {			child.cancel(false, parent.Err(), Cause(parent))		})		c.Context = stopCtx{			Context: parent,			stop:    stop,		}		c.mu.Unlock()		return	}     // 开启一个守护协程，时刻监听，第一个判断父亲是不是被终止了    // 如果父亲被终止了，就应该给孩子也砍一刀，让他们也都终止    // 如果孩子被终止了，那就被终止了，什么也不需要处理，传播具有单向性	goroutines.Add(1)	go func() {		select {		case <-parent.Done():			child.cancel(false, parent.Err(), Cause(parent))		case <-child.Done():		}	}()}

parentCancelCtx用于判断是不是cancelCtx类型

func (c *cancelCtx) Value(key any) any {    // 这里为什么要加入这个判断，在后续会介绍，主要就是用于判断    // 其自身是否是一个cancelCtx类型，这个cancelCtxKey是一个定值	if key == &cancelCtxKey {		return c	}	return value(c.Context, key)} func parentCancelCtx(parent Context) (*cancelCtx, bool) {	done := parent.Done()	if done == closedchan || done == nil {		return nil, false	}	p, ok := parent.Value(&cancelCtxKey).(*cancelCtx)	if !ok {		return nil, false	}	pdone, _ := p.done.Load().(chan struct{})	if pdone != done {		return nil, false	}	return p, true}

再看一下返回的闭包函数吧

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

func (c *cancelCtx) cancel(removeFromParent bool, err, cause error) {	if err == nil {		panic("context: internal error: missing cancel error")	}	if cause == nil {		cause = err	}	c.mu.Lock()	if c.err != nil {		c.mu.Unlock()		return // already canceled	}	c.err = err	c.cause = cause	d, _ := c.done.Load().(chan struct{})	if d == nil {        // closedchan 这里是一个全局chan        // 关闭，从而取消监听，Store就是为了确保原子性和可见性		c.done.Store(closedchan)	} else {		close(d)	}	for child := range c.children {		// NOTE: acquiring the child's lock while holding parent's lock.		child.cancel(false, err, cause)	}	c.children = nil	c.mu.Unlock() 	if removeFromParent {		removeChild(c.Context, c)	}} // removeChild removes a context from its parent.func removeChild(parent Context, child canceler) {	if s, ok := parent.(stopCtx); ok {		s.stop()		return	}	p, ok := parentCancelCtx(parent)	if !ok {		return	}	p.mu.Lock()	if p.children != nil {		delete(p.children, child)	}	p.mu.Unlock()}

3.3 timerCtx

接下来看第三个实现的类

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

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

这样就有了实现时停的操作，它对Dealine进行了一个重写，其他都是继承的cancelCtx的

Deadline返回的是 deadline time.Time

3.3.1WithTimeout和WithDeadline

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) {	return WithDeadlineCause(parent, d, nil)}

这两个函数他们的参数就可以看出区别，context.WithTimeout是指经过的时间段，而WithDeadline则是指时间点。

这里属于是超时取消。

3.4 valueCtx

type valueCtx struct {    Context    key, val any}

说一下这个valueCtx吧，在不同位置设置的value其实在查找方面是有问题的，比如你在最下面那一层去存放，也就是B下面的子节点存放value，只有A和B才可以访问这个value，C和D是无法访问到的。

3.4.1WithValue

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}}

通过这个函数来设置value值。