0 前言

context 是 golang中的经典工具,主要在异步场景中用于实现并发协调以及对gorouting的生命周期控制,除此之外,context还兼有一定的数据储存能力。

1 核心数据结构

1.1 context.Context

type Context interface{
    Deadline() (deadline time.Time,ok bool) //返回ctx的过期时间
    Done() <-chan struct{}    //返回用以标识ctx是否结束的chan
    Err() error //返回ctx的错误
    Value(key any) any //返回ctx存放的对应key的value
}

Context 为 interface,定义了四个核心api:

  • Deadline:返回ctx的过期时间
  • Done:返回用以标识ctx是否结束的chan
  • Err:返回ctx的错误
  • Value:返回ctx存放的对应key的value

1.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超时时会报此错误

2 emptyCtx

2.1 类的实现

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

2.2 context.Backgroud() & context.TODO()

var (
    backgroud = new(emptyCtx)
    todo = new(emptyCtx)
)

func Backgroud() Conext{
    return backgroud
}

func TODO() context{
    return todo
}

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

3 cancelCtx

3.1 cacelCtx 数据结构

type cancelCtx struct{
    Context
    
    mu sync.Mutex
    done atomic.Value
    children map[canceler]struct{}
    err error
}

type canceler interface{
    cancel(removeFromParent bool,err error)
    Done() <-chan struct{}
}
  • embed了一个context作为其父context可见,cancelCtx必然为某个context的子context
  • 内置了一把锁,用以协调并发场景下的资源获取
  • done:实际类型为 chan struct{},即用于反映cancelCtx生命周期的通道
  • children:一个set,指向cancelCtx的所有子context
  • err:记录了当前cancelCtx的错误,必然为某个context的子context;

3.2 Deadline方法

cancelCtx未实现该方法,仅是embed了一个带有deadline方法的context interface,因此倘若直接调用这个方法会报错

3.3 Done方法

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是否存在,若存在则返回 (duoble check)
  • 初始化chan储存到atomic.Value中,并返回。(懒加载)

3.4 Err方法

func (c *cancelCtx) Err() error{
    c.mu.lock()
    err := c.err
    c.mu.Unlock()
    return err
}
  • 加锁
  • 读取cancelCtx.err;
  • 解锁
  • 返回结果

3.5 Value方法

type (c *cancelCtx) Value(key any)any{
    if key == &cacnelCtxKey{
        retrun c
    }
    return value(c.Context,key)
}
  • 倘若key等于特定值 &cancelCtxKey,则返回cancelCtx自身指针;
  • 否则遵循valueCtx的思路返回

3.6 context.WithCancel()

3.6.1 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) }
}
  • 检验父context是否为空
  • 注入父context构造好一个新的cancelCtx
  • 在propagateCancel方法启动一个协程。以保证父context终止时,该cancelCtx也会被终止
  • 将cancelCtx返回,连带返回一个用以终止该cancelCtx的闭包函数

3.6.2 newCancelCtx

func newCancelCtx(parent Context) cancelCtx{
    return canceCtx{Context:parent}
}
  • 注入父context后,返回一个新的cancelCtx

3.6.3 propagateCancel

func propagateCancel(parent Context, child canceler) {
    done := parent.Done()
    if done == nil {
        return // parent is never canceled
    }

    select {
    case <-done:
        // parent is already canceled
        child.cancel(false, parent.Err())
        return
    default:
    }

    if p, ok := parentCancelCtx(parent); ok {
        p.mu.Lock()
        if p.err != nil {
            // parent has already been canceled
            child.cancel(false, p.err)
        } else {
            if p.children == nil {
                p.children = make(map[canceler]struct{})
            }
            p.children[child] = struct{}{}
        }
        p.mu.Unlock()
    } else {
        atomic.AddInt32(&goroutines, +1)
        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

进一步观察parentCancelCtx是如何校验parent是否为cancelCtx的类型

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
}
  • 倘若parent的channel已关闭或者是不会被cancel的类型,则返回false
  • 倘若以特定的cancelCtxKey从parent中取值,取得的value是parent本身,则返回true(基于cancelCtxKey)为key取值是返回cancelCtx自身,是cancelCtx特有的协议

3.6.4 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 // already canceled
    }
    c.err = err
    d, _ := 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)
    }
    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的channcel,若channcel此前未初始化,则直接注入一个clousedChan,否则关闭改channcel
  • 遍历当前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不是cnacelCtx,直接返回(因为只有cancelCtx才有children set)
  • 加锁
  • 从parent的children set 中删除对应child
  • 解锁返回

4 timerCtx

4.1 类

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

    deadline time.Time
}

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

4.2 timerCtx.Deadline

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

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

4.3 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中移除,若是则进行处理
  • 加锁
  • 停止 timer.Timer
  • 解锁返回

4.4 context.WithTimeout & context.WithDeadline

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

context.WithTimout方法用于构造一个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的错误
  • 加锁
  • 启动timer.Timer,设定一个延时时间,即达到过期时间后会终止该timerCtx,并返回DeadlineExceeded的错误
  • 解锁
  • 返回timerCtx,已经一个封装了cancel逻辑的闭包cancel函数

5 valueCtx

5.1 类

type valueCtx struct {
    Context
    key, val any
}
  • valueCtx同样继承了一个parent context
  • 一个valueCtx中仅有一组kv对

5.2 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进行返回

5.3 valueCtx用法小结

阅读源码可以看出,valueCtx不适合视为存储介质,存放大量key value数据,原因有三:

  • 一个valueCtx实例只能存一个kv对,因此n个kv对会嵌套n个valueCtx,会造成空间浪费
  • 基于k寻找v的过程是线性的,时间复杂度O(N);
  • 不支持基于k的去重,想通k可能重复存在,并基于起点不同,返回的不同的v由此得知,valueContext的定位类似于请求头,只适合存放少量作用于较大的全局meta数据

5.4 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

文章内容来自于跟敲学习视频教程 @小徐先生的编程世界

Last modification:November 8, 2023
如果觉得我的文章对你有用,请收藏本站