Go 源码之 context

// valueCtx类的创建
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方法，获取数据
func (c *valueCtx) Value(key any) any {
    if c.key == key {
        return c.val
    }
  // 递归从 父 context中获取数据
    return value(c.Context, key)
}

// 递归查找数据，找不到则从父节点查找
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)
        }
    }
}

// 创建一个cancelCtx实例，返回一个cacelCtx实例，和一个CancelFunc函数
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
    if parent == nil {
        panic("cannot create context from nil parent")
    }
    c := newCancelCtx(parent)
    propagateCancel(parent, &c)

  // 返回一个cancelCtx实例
  // 返回一个CancelFunc函数，函数调用时执行cancel：removeFromParent=true，err=errors.New("context canceled")
    return &c, func() { c.cancel(true, Canceled) }
}

// 方法实现了 context 包中上下文的取消功能，确保所有子级也被正确地取消。
// 关闭 c.done，取消 c 的所有子级（即其派生的上下文），并且如果 removeFromParent 为 true，则将 c 从其父级的子级列表中删除.
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
    if err == nil { // 必须有err
        panic("context: internal error: missing cancel error")
    }
    c.mu.Lock()
    if c.err != nil { // 如果当前的ctx已经有err，表已退出，无须执行退出
        c.mu.Unlock()
        return // already canceled
    }
    c.err = err // 将退出的err赋值给当前ctx的err字段
    d, _ := c.done.Load().(chan struct{})
    if d == nil {
        c.done.Store(closedchan) // 如果当前ctx的done不存在，则赋值一个默认关闭的chan
    } else {
        close(d) // 关闭chan，通知其他协程
    }
  //遍历每一个children,取消所有孩子节点
    for child := range c.children {
        // NOTE: acquiring the child's lock while holding parent's lock.
        child.cancel(false, err) // 为什么这里是false？根节点和子节点断开即可，子节点和子节点之间的联系断不断没意义
    }
    c.children = nil
    c.mu.Unlock() //解锁

    if removeFromParent {     //如果为true，则将当前节点和父节点断开链接
        removeChild(c.Context, c)
    }
}

func main() {
    // 创建一个ctx
    parentCtx := context.Background()
    // 创建一个带cancel的ctx
    ctx, cancel := context.WithCancel(parentCtx)

    go func(ctx context.Context) {
      select {
      case <-ctx.Done(): // 当ctx的cancel执行之后，协程完成退出
          fmt.Println("context canceled")
      }

    }(ctx)
    time.Sleep(2 * time.Second)
    cancel() // 退出所有的ctx
}

// 该方法返回一个带有超时时间的timerCtx。与WithDeadline方法不同的是，WithTimeout方法的参数是一个持续时间（Duration），而不是一个时间点
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
    return WithDeadline(parent, time.Now().Add(timeout))
}
// 该方法返回一个带有截止时间的timerCtx。如果在截止时间之前没有取消Context，定时器会自动触发取消操作
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)
    }
      //创建timerCtx实例
    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) }
}

// 实现了cancel
func (c *timerCtx) cancel(removeFromParent bool, err error) {
    c.cancelCtx.cancel(false, err)
    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()
}

func main() {
  // 2秒后超时关闭
    ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(2*time.Second))
    defer cancel() // return时自动关闭

    select {
    case <-ctx.Done():// 2秒后会执行
        fmt.Println("Context cancelled")
    case <-time.After(3 * time.Second): // 3秒的定时器，因为ctx设置的2秒，所以不会执行
        fmt.Println("Time out")
    }
}