Context 是什么

1. 译为上下文
2. 用于进程之间信息和信号的传递
3. 用于服务之间的信号和信息从传递

Context 的功能

1. Context 可以用于不同的api或者进程之间传递(携带键值对传递),不要传递 nil Context
2. 传递取消信号(主动取消，超时/时限取消)，因为Context是树结构，所以传递是单向传递的，只有父节点取消的时候，才会把取消的信号传递给父节点的衍生子节点
3. Context需要显示传递给他所需要的函数，并且需要他的函数作为第一个参数，通常命名为ctx

应用场景

1. 用于父子协程间取消信号传递
2. 用于客服端与服务器之间的信息传递
3. 用于设置请求超时时间等

源码分析

1.10 Context核心结构

   本文都是围绕一下进行讨论的，无非就是实现这四个方法的逻辑不同。方法的具体实现，将会在下面具体讲解，现在先让大家对Context有个宏观的认知

• 一个接口：

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

1. Deadline(): 返回一个完成工作的截止时间，这个截止时间代表上下文被取消的时间，这个时间之后所有的衍生协程都将会取消。如果没有截止时间，将会返回false
2. Done() :返回一个Context中的channel，这个channel会在当前任务完成工作的时候关闭，如果关闭的时候无法取消上下文，则Done可能返回nil。多次调用Done方法会返回同一个channel。
3. Err() :返回Context结束的原因，他只会在Done方法对应的Channel关闭的时候关闭返回非空值，如果context被取消，会返回context.Canceled如果Context超时，会返回Context.DeadlineExceeded错误
4. Value():从Context从获取对应的键值对，如果未设置键值对则返回nil。相同的key取value会返回相同的值。因为这四个方法都是幂等的

• 四个实现：

1. emptyCtx (): 实现了一个空的context用作根节点，TODO(),Background(),都是基于他实现的
2. cancelCtx (): 实现一个能够自己取消的Context
3. timerCtx (): 实现一个通过定时器timer和截止时间deadline定时取消的context
4. valueCtx (): 实现一个可以通过 key、val 两个字段来存数据的context

• 十个方法：

1. Background (): Background 返回一个emptyCtx作为根节点

2. TODO (): TODO 返回一个emptyCtx作为未知节点，如果你不知道使用哪个Context可以使用此方法

3. WithCancel(): WithCancel 入参是一个父Context，return一个子Context和cancelCtx（主动取消Context），如果想取消Context可以调用cancelCtx()

4. WithDeadline (): WithDeadline 入参是一个父Context和一个过期时间， 返回一个子Context和timerCtx,如果时间超时，那么他会自动的调用timerCtx()方法

5. WithTimeout (): WithTimeout 入参是一个父Context和一段时间， 返回一个子Context和timerCtx，如果传入的是3秒，那么3秒后，他会自动的调用timerCtx()方法

6. WithCancelCause(): WithCancelCause,和WithCancel不同点就是他可以自定义error而WithCancel不能

7. WithDeadlineCause(): 同上

8. WithTimeoutCause(): 同上

9. AfterFunc(): AfterFunc入参是一个Context和一个func()，在该Context取消的时候，会执行该func。可以解决以往的一些合并取消上下文和串联处理的复杂场景。AfterFunc 安排在 ctx 完成后在自己的 goroutine 中调用 f（取消或超时）。如果 ctx 已经完成，AfterFunc 会立即在自己的 goroutine 中调用 f。

10. WithoutCancel(): WithoutCance返回一个父级Context的副本，即使父Context关闭，生成的父Contest的副本也不会关闭。

1.1Err错误

   从下面的err可以看出，有两个错误方法，Canceled：Context取消时返回的err，DeadlineExceeded ：Context截止时间超时的err

// Canceled is the error returned by [Context.Err] when the context is canceled.
var Canceled = errors.New("context canceled")// DeadlineExceeded is the error returned by [Context.Err] when the context's
// deadline passes.
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 }

2 .1 emptyCtx

   字如其名就是一个空的Context，无法被取消，没有值，也没有超时时间。

// An emptyCtx is never canceled, has no values, and has no deadline.
// It is the common base of backgroundCtx and todoCtx.
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
}

1. Deadline(): 方法会返回一个公元元年的时间以及false的flag。表示这个Context没有超时时间
2. Done() : 方法返回一个nil，如果用户读取或者写入这个Channel，会造成阻塞
3. Err(: Err的错误返回一个nil，证明这个方法不会有err
4. Value: Value值返回nil，证明这个方法不会有value

3.1 Background() 和 TODO()

   从源码可以看出这两个方法其实都是返回的emptyCtx 的一个实例，只是他们的表达方式不一样，他们两个继承了emptyCtx 所有的特点，，无法被取消，没有值，也没有超时时间。

   Background()：上下文的默认值，相当于root，所有的Context都应该从这里衍生出来，一般会在main中作为最顶层的Context

   TODO()：Todo就是表示这个地方还没有完成，代表目前还不知道用哪个Context传递，或者根本没有Context，但是业务又需要传递Context，这时TODO就派上用场了

type backgroundCtx struct{ emptyCtx }func (backgroundCtx) String() string {return "context.Background"
}type todoCtx struct{ emptyCtx }func (todoCtx) String() string {return "context.TODO"
}func Background() Context {return backgroundCtx{}
}
func TODO() Context {return todoCtx{}
}

4.1.1 cancelCtx

   cancelCtx 是一个能够被取消的Context，其中他实现了Context接口，他是一个匿名字段，可以看成Context.

type canceler interface {cancel(removeFromParent bool, err, cause error)Done() <-chan struct{}
}
type cancelCtx struct {Contextmu       sync.Mutex            // protects following fieldsdone     atomic.Value          // of chan struct{}, created lazily, closed by first cancel callchildren map[canceler]struct{} // set to nil by the first cancel callerr      error                 // set to non-nil by the first cancel callcause    error                 // set to non-nil by the first cancel call
}

• Context：嵌入了一个Context作为父Context，表示cancelCtx 肯定是某一个Context的子节点

• mu ：互斥锁，用来保证并发安全

• done：实际的类型是 chan struct{},用来反应cancelCtx 生命周期的通道，如果是cancelCtx 关闭，那么就会向done发送信号，用来表示传递关闭信号。其中内部是使用atomic.Value实现的，会读取上次最近存储的chan struct{}

• children：指向 cancelCtx 的所有子 context，在第一次调用的时候为nil

• err：记录了当前 cancelCtx 的错误.

• cause：自定义err，返回自定义的cancelCtx 错误

4.1.2 Deadline 方法

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

4.1.2 Done 方法

  Done返回一个只读的通道，当Context取消的时候，该通道就会关闭，你可以监听这个通道检测Context是否被关闭，将done初始化。

• 检查atomic.Value 是否存储了chan struct{}，如果存储的有就返回原来的实例化的chan struct{}
• 如果atomic.Value没有存储，就加锁，然后在判断一下是否有没有存储（双重保险），没有了在进行实例化，最后返回实例化后的chan struct{}

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

4.1.2 Err 方法

   这个就是读取cancelCtx的err，然后进行返回

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

4.1.2 Value 方法

倘若 key 特定值 &cancelCtxKey，则返回 cancelCtx 自身的指针，否则就会取值return

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

了解了cancelCtx 结构之后进入真正的主题

4.2 WithCancel() 和 WithCancelCause()

   WithCancel()：返回的是一个继承了父Context的新Context（cancelCtx），和一个CancelFunc方法，如果调用CancelFunc，这个context 将会取消。

   WithCancelCause()：返回的内容一样，就是CancelFunc方法多了一个自定义的err。下面是使用示例，myError是自定义的err。

	ctx, cancel := context.WithCancelCause(parent)cancel(myError) //返回myErrorcontext.Cause(ctx) 

type CancelFunc func()func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {c := withCancel(parent)return c, func() { c.cancel(true, Canceled, nil) }
}type CancelCauseFunc func(cause error)func WithCancelCause(parent Context) (ctx Context, cancel CancelCauseFunc) {c := withCancel(parent)return c, func(cause error) { c.cancel(true, Canceled, cause) }
}func withCancel(parent Context) *cancelCtx {if parent == nil {panic("cannot create context from nil parent")}c := &cancelCtx{}c.propagateCancel(parent, c)return c
}

• 先判断父Context是否为nil，如果为nil直接panic，然后在重新实例化一个子context
• 在 propagateCancel 方法内启动一个守护协程，以保证父 context 终止时，该 cancelCtx 也会被终止

4.2.2 propagateCancel

   如果父context取消了，那么他的所有衍生context都应该被取消

func (c *cancelCtx) propagateCancel(parent Context, child canceler) {c.Context = parentdone := parent.Done()if done == nil {return // parent is never canceled}select {case <-done:// parent is already canceledchild.cancel(false, parent.Err(), Cause(parent))returndefault:}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 canceledchild.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}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():}}()
}

• c.Context = parent，把该context指向父context，这样就知道父context有哪些子context了

• 判断父context是否为不可取消类型，如果是，就跳过，如果不是就监听父context是否已经取消了，如果是取消了就把该子context取消。并把父err，传递给子err

• 如果parent 是 cancelCtx 的类型，则加锁，并将子 context 添加到 parent 的 children map 当中，假如以后父context取消，可以直接用children map 取消所有的子context

• 如果parent 实现了afterFuncer接口，把cancel函数封装成一个stop函数，进行延迟取消。赋值给子context的结构体中。后续会调用这个afterFuncer

• 如果 parent 没有实现afterFuncer接口，则启动一个协程，通过多路复用的方式监控 parent 状态，如果终止，则同时终止子 context，并把parent 的 err传递给子context，如果孩子终止则直接跳过，因为不影响parent 。这里启动协程是主要监听parent，如果parent取消则立即取消子context。

4.2.3 cancelCtx.cancel()

   在propagateCancel守护协程中，知道了怎么终止协程cancel(false, parent.Err(), Cause(parent))。但是你知道怎么实现的吗？来看源代码

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 = errc.cause = caused, _ := c.done.Load().(chan struct{})if d == nil {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 = nilc.mu.Unlock()if removeFromParent {removeChild(c.Context, c)}
}

• 可以看到cancel需要三个入参，一个是是否需要从父map[canceler]struct{}剔除，如果为true就剔除。第二个是取消context的错误是必传的，第三个是自定义err。
• 如果err为nil直接panic，检查cancelCtx的err是否已经为空，如果不为空则解锁return，为空就把入参赋值给err和cause
• 加载cancelCtx 的 channel，如果没有初始化，则初始化一个closedchan，反之就关闭Channel。遍历当前cancelCtx的children 把他的衍生孩子都进行取消。然后把children 清空赋值为nil。
• 下面是removeChild的方法，先判断parent是否实现了stopCtx结构体，如果实现了就证明它实现了afterFunction这个接口，需要在移除的时候，运行在propagateCancel中添加的stopCtx.stop方法。
• 如果parent不是cancelCtx，那么就返回，只有cancelCtx才有children ，如果是cancelCtx类型，就把children map中的child 删除，最后解锁返回

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

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

4.3 WithTimeout ()，WithDeadline()，WithDeadlineCause(),WithTimeoutCause()

因为这四个方法实现的逻辑都基本是一样的，下面将会讲解怎么实现具体逻辑

4.3.1 timerCtx 结构

timerCtx 在 cancelCtx 基础上又做了一层封装，他继承了cancelCtx结构体，实现了cancelCtx的所有能力，然后外加了一个定时取消的Context，和到截止时间取消的Context

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

4.3.2 Deadline结构

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

在之前讲解的 WithCancel() 和 WithCancelCause()中，都没有实现Deadline()这个方法，这个方法用于展示过期时间

4.3.3 cancel结构

因为他继承了cancelCtx，所以可以之间调用cancelCtx.cancel，进行取消操作，然后判断是否需要把孩子context从map中删除，然后停止timer

func (c *timerCtx) cancel(removeFromParent bool, err, cause error) {c.cancelCtx.cancel(false, err, cause)if removeFromParent {// Remove this timerCtx from its parent cancelCtx's children.removeChild(c.cancelCtx.Context, c)}c.mu.Lock()if c.timer != nil {c.timer.Stop()c.timer = nil}c.mu.Unlock()
}

4.3.4 String结构

这个是把context进行name的拼接，调用这个方法会把context的名字return

func (c *timerCtx) String() string {return contextName(c.cancelCtx.Context) + ".WithDeadline(" +c.deadline.String() + " [" +time.Until(c.deadline).String() + "])"
}

4.4.1 WithDeadline 结构

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {return WithDeadlineCause(parent, d, nil)
}// WithDeadlineCause behaves like [WithDeadline] but also sets the cause of the
// returned Context when the deadline is exceeded. The returned [CancelFunc] does
// not set the cause.
func WithDeadlineCause(parent Context, d time.Time, cause error) (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{deadline: d,}c.cancelCtx.propagateCancel(parent, c)dur := time.Until(d)if dur <= 0 {c.cancel(true, DeadlineExceeded, cause) // deadline has already passedreturn c, func() { c.cancel(false, Canceled, nil) }}c.mu.Lock()defer c.mu.Unlock()if c.err == nil {c.timer = time.AfterFunc(dur, func() {c.cancel(true, DeadlineExceeded, cause)})}return c, func() { c.cancel(true, Canceled, nil) }
}

• 从代码可以看到WithDeadline其实内部就是调用的WithDeadlineCause，只不过他的自定义err为nil。
• 检查parent 是否为nil，校验 parent 的过期时间是否早于自己，如果是就返回 WithCancel(parent)，然后构造一个timerCtx，启用守护进程，判断过期的时间是否已经到了，如果到则取消context，判断context的err是否为nil，如果为nil则设定一个延时时间，到过期时间的时候会终止该 timerCtx，并返回 的错误。最后返回一个timerCtx和cancel函数