Go-深入理解context

type Context interface {
    // 返回当前任务取消的时间， ok表示是否设置deadline
	Deadline() (deadline time.Time, ok bool)

    // done返回一个只读channel，当cancel被调用或者deadline过期后，会close 这个channnel
	Done() <-chan struct{}

    // 如果Done没有被关闭，返回nil，否则返回一个非nil的error
	Err() error

    // value返回这个上下文关联key的value，如果没有设置，则返回nil
	Value(key interface{}) interface{}
}

var (
	background = new(emptyCtx)
	todo       = new(emptyCtx)
)

type cancelCtx struct {
	Context

	// 锁
	mu       sync.Mutex            // protects following fields
	// 首次取消会close
	done     chan struct{}         // created lazily, closed by first cancel call
	// 首次cancel，会被设置成nil
	children map[canceler]struct{} // set to nil by the first cancel call
	// 首次取消是个非nil的error·
	err      error                 // set to non-nil by the first cancel call
}

type timerCtx struct {
	cancelCtx
	// 被cancelCtx lock保护
	timer *time.Timer // Under cancelCtx.mu.

	deadline time.Time
}

type valueCtx struct {
	Context
	key, val interface{}
}

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
	c := newCancelCtx(parent)
	propagateCancel(parent, &c)
	return &c, func() { c.cancel(true, Canceled) }
}

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
	if cur, ok := parent.Deadline(); ok && cur.Before(d) {
        // The current deadline is already sooner than the new one.
        // parent的deadline早于当前的deadline，肯定parent先达到expired
		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) }
}

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

func WithValue(parent Context, key, val interface{}) Context {
	if key == nil {
		panic("nil key")
	}
	if !reflect.TypeOf(key).Comparable() {
		panic("key is not comparable")
	}
	return &valueCtx{parent, key, val}
}

func propagateCancel(parent Context, child canceler) {
	if parent.Done() == nil {
		return // parent is never canceled
	}
	if p, ok := parentCancelCtx(parent); ok {
		p.mu.Lock()
		if p.err != nil {
			// parent 已经关闭了
			child.cancel(false, p.err)
		} else {
			if p.children == nil {
				p.children = make(map[canceler]struct{})
			}
			p.children[child] = struct{}{}
		}
		p.mu.Unlock()
	} else {
		go func() {
			// 启动监听parent和child的goroutine
			select {
			case <-parent.Done():
				child.cancel(false, parent.Err())
			case <-child.Done():
			}
		}()
	}
}

func parentCancelCtx(parent Context) (*cancelCtx, bool) {
	for {
		switch c := parent.(type) {
		case *cancelCtx:
			return c, true
		case *timerCtx:
			return &c.cancelCtx, true
		case *valueCtx:
			parent = c.Context
		default:
			return nil, false
		}
	}
}