Context详解

1type Context interface {
2	Deadline() (deadline time.Time, ok bool)
3	Done() <-chan struct{}
4	Err() error
5	Value(key any) any
6}

 1var (
 2    background = new(emptyCtx)
 3    todo       = new(emptyCtx)
 4)
 5func Background() Context {
 6    return background
 7}
 8func TODO() Context {
 9    return todo
10}
11type emptyCtx int
12func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
13	return
14}
15func (*emptyCtx) Done() <-chan struct{} {
16	return nil
17}
18func (*emptyCtx) Err() error {
19	return nil
20}
21func (*emptyCtx) Value(key any) any {
22	return nil
23}

1type timerCtx struct {
2	cancelCtx
3	timer *time.Timer // Under cancelCtx.mu.
4
5	deadline time.Time
6}
7func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
8	return c.deadline, true
9}

 1package main
 2
 3import "fmt"
 4
 5type I1 interface {
 6	Done()
 7	To()
 8}
 9
10type Cancel struct {
11	I1
12}
13
14func (c *Cancel) To() {
15	fmt.Println("to")
16}
17func (*Cancel) String() string {
18	return "c"
19}
20func main() {
21	var c I1 = &Cancel{}
22	c.To()
23	fmt.Println(c.Done)
24}

1// 发生了取消
2// Canceled is the error returned by Context.Err when the context is canceled.
3var Canceled = errors.New("context canceled")  
4
5// 发生了过期、超时
6// DeadlineExceeded is the error returned by Context.Err when the context's
7// deadline passes.
8var DeadlineExceeded error = deadlineExceededError{}

 1// A valueCtx carries a key-value pair. It implements Value for that key and
 2// delegates all other calls to the embedded Context.
 3type valueCtx struct {
 4	Context
 5	key, val any
 6}
 7
 8func (c *valueCtx) Value(key any) any {
 9    if c.key == key {
10        return c.val
11    }
12	// 递归往parent context 找，找到就停下了， 没找到会一直找到最顶级的emptyCtx，那么返回的就是nil。 
13    return value(c.Context, key)
14}

 1// A cancelCtx can be canceled. When canceled, it also cancels any children
 2// that implement canceler.
 3type cancelCtx struct {
 4	Context
 5
 6	mu       sync.Mutex            // protects following fields
 7	done     atomic.Value          // of chan struct{}, created lazily, closed by first cancel call
 8	children map[canceler]struct{} // set to nil by the first cancel call
 9	err      error                 // set to non-nil by the first cancel call
10}

 1func (c *cancelCtx) Done() <-chan struct{} {
 2	d := c.done.Load()
 3	if d != nil {
 4		return d.(chan struct{})
 5	}
 6	c.mu.Lock()
 7	defer c.mu.Unlock()
 8	d = c.done.Load()
 9	if d == nil {
10		d = make(chan struct{})
11		c.done.Store(d)
12	}
13	return d.(chan struct{})
14}

 1// propagateCancel arranges for child to be canceled when parent is.
 2func propagateCancel(parent Context, child canceler) {
 3	done := parent.Done()
 4	if done == nil {
 5		return // parent is never canceled
 6	}
 7    //判断一遍是否  parent是否已经已经取消了
 8	select {
 9	case <-done:
10		// parent is already canceled
11		child.cancel(false, parent.Err())
12		return
13	default:
14	}
15    // parentCancelCtx这个方法就是找到 最近的cancelCtx的祖先，找到了就在它到children中去放入child context
16	if p, ok := parentCancelCtx(parent); ok {
17		p.mu.Lock()
18		if p.err != nil {
19			// parent has already been canceled
20			child.cancel(false, p.err)
21		} else {
22			if p.children == nil {
23				p.children = make(map[canceler]struct{})
24			}
25			//将子context 放到 最近的 cancelCtx类型祖先的 children中
26			p.children[child] = struct{}{}
27		}
28		p.mu.Unlock()
29	} else {
30		//这个计数器只为测试使用
31		atomic.AddInt32(&goroutines, +1)
32		go func() {
33			select {
34			case <-parent.Done():
35				child.cancel(false, parent.Err())
36			case <-child.Done():
37			}
38		}()
39	}
40}

 1func (c *cancelCtx) cancel(removeFromParent bool, err error) {
 2	//  Canceled = errors.New("context canceled") 肯定是传这个err 
 3	if err == nil {
 4		panic("context: internal error: missing cancel error")
 5	}
 6	c.mu.Lock()
 7	if c.err != nil {
 8		c.mu.Unlock()
 9		return // already canceled
10	}
11	c.err = err
12	d, _ := c.done.Load().(chan struct{})
13	if d == nil {
14		//没有done chan 就放个 的已关闭的chan进去
15		c.done.Store(closedchan)
16	} else {
17		close(d)
18	}
19	for child := range c.children {
20		// NOTE: acquiring the child's lock while holding parent's lock.
21		child.cancel(false, err)
22	}
23	c.children = nil
24	c.mu.Unlock()
25
26	if removeFromParent {
27		removeChild(c.Context, c)
28	}
29}