golang Context源码阅读

func childSvc1(upstream <-chan) {
    downstream := make(chan struct{}, 0)
    defer close(downstream)
    go childSvc1_1(downstream)
    go childSvr1_2(downstream)
  
    for {
        select {
            case <-upstream:
                close(downstream)
                return
            default:
                // 处理业务...

                // 因为某些原因需要取消下游服务
                close(downstream)
        }
    }
}

import "context"

func childSvc1(ctx context.Context) {
    cancel, ctx := context.WithCancel(ctx) // 创建子Context
    defer cancel()
    go childSvc1_1(ctx)
    go childSvr1_2(ctx)

    for {
        select {
            case ctx.Done():
            	return
            default:
                // 处理业务...

                // 因为某些原因需要取消下游服务
                cancel()
        }
    }
}

func childSvc1(ctx context.Context) {
  cancel, ctx := context.WithTimeout(ctx, 10 * time.Seconds) // 创建子Context
  defer cancel()
  go childSvc1_1(ctx)
  go childSvr1_2(ctx)
  
  for {
    select {
      case ctx.Done():
      	return
    	default:
      	// 处理业务...

				// 因为某些原因需要取消下游服务
				cancel()
    }
  }
}

type Context interface {
    // 返回超时时间点
    Deadline() (deadline time.Time, ok bool)

    // 返回chan，读这个chan会阻塞，直到Context被取消
    Done() <-chan struct{}

    // 只有两种可能的错误值：
    // Canceled：被取消
    // DeadlineExceeded：超时
    Err() error

    // 取出key对应的value，对应数据传递功能
    Value(key any) any
}

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
}

type backgroundCtx struct{ emptyCtx }

func (backgroundCtx) String() string {
	return "context.Background"
}

// Background returns a non-nil, empty [Context]. It is never canceled, has no
// values, and has no deadline. It is typically used by the main function,
// initialization, and tests, and as the top-level Context for incoming
// requests.
func Background() Context {
	return backgroundCtx{}
}

type todoCtx struct{ emptyCtx }

func (todoCtx) String() string {
	return "context.TODO"
}

// TODO returns a non-nil, empty [Context]. Code should use context.TODO when
// it's unclear which Context to use or it is not yet available (because the
// surrounding function has not yet been extended to accept a Context
// parameter).
func TODO() Context {
	return todoCtx{}
}

// A cancelCtx can be canceled. When canceled, it also cancels any children
// that implement canceler.
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
	cause    error                 // set to non-nil by the first cancel call
}

func withCancel(parent Context) *cancelCtx {
	if parent == nil {
		panic("cannot create context from nil parent")
	}
	c := &cancelCtx{}
	c.propagateCancel(parent, c)
	return c
}

// propagateCancel arranges for child to be canceled when parent is.
// It sets the parent context of cancelCtx.
func (c *cancelCtx) propagateCancel(parent Context, child canceler) {
	c.Context = parent
  
	...
  
	if p, ok := parentCancelCtx(parent); ok {
		// parent is a *cancelCtx, or derives from one.
    p.mu.Lock()
    
    ...

		p.children[child] = struct{}{}
    p.mu.Unlock()
		return
	}

	...

	goroutines.Add(1)
	go func() {
		select {
		case <-parent.Done():
			child.cancel(false, parent.Err(), Cause(parent))
		case <-child.Done():
		}
	}()
}

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
	c := withCancel(parent)
	return c, func() { c.cancel(true, Canceled, nil) }
}

// cancel closes c.done, cancels each of c's children, and, if
// removeFromParent is true, removes c from its parent's children.
// cancel sets c.cause to cause if this is the first time c is canceled.
func (c *cancelCtx) cancel(removeFromParent bool, err, cause error) {
    ...

    c.mu.Lock()
    ...
  
	d, _ := c.done.Load().(chan struct{})
	if d == nil {
		c.done.Store(closedchan)
	} else {
		close(d)
	}
	for child := range c.children {
		child.cancel(false, err, cause)
	}
	c.children = nil
	c.mu.Unlock()

	if removeFromParent {
		removeChild(c.Context, c)
	}
}

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

	deadline time.Time
}

func WithDeadlineCause(parent Context, d time.Time, cause error) (Context, CancelFunc) {
    ...
  
	c := &timerCtx{
		deadline: d,
	}
	c.cancelCtx.propagateCancel(parent, c)
	
    ...
  
	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) }
}

func (c *timerCtx) cancel(removeFromParent bool, err, cause error) {
	c.cancelCtx.cancel(false, err, cause)
    ...
  
	c.timer.Stop()
    ...
}

type valueCtx struct {
	Context
	key, val any
}

type afterFuncCtx struct {
	cancelCtx
	once sync.Once // either starts running f or stops f from running
	f    func()
}

func AfterFunc(ctx Context, f func()) (stop func() bool) {
	a := &afterFuncCtx{
		f: f,
	}
	a.cancelCtx.propagateCancel(ctx, a)
	return func() bool {
		stopped := false
		a.once.Do(func() {
			stopped = true
		})
		if stopped {
			a.cancel(true, Canceled, nil)
		}
		return stopped
	}
}

func (a *afterFuncCtx) cancel(removeFromParent bool, err, cause error) {
	a.cancelCtx.cancel(false, err, cause)
	if removeFromParent {
		removeChild(a.Context, a)
	}
	a.once.Do(func() {
		go a.f()
	})
}