golang源码分析-Context

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// A Context carries a deadline, a cancellation signal, and other values across
// API boundaries.
//
// Context's methods may be called by multiple goroutines simultaneously.
type Context interface {
	Deadline() (deadline time.Time, ok bool)
	Done() <-chan struct{}
	Err() error
	Value(key any) any
}

1
2
3
4
5
6
7

func test(ctx context.Context) {
	fmt.Println("lalala")
	select {
	case <- ctx.Done():
		// close resourse
	}
}

1
2
3
4
5

// 第一个参数为父context, context.TODO()类型下文再介绍。key为abc, value为123
ctx := context.WithValue(context.TODO(), "abc", 123)
// 取到的value强转为int类型
result := ctx.Value("abc").(int)
fmt.Println(result)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// emptyCtx是一个空的context对象，它永远不会被取消，没有任何值，也没有任何截止日期。它不是struct{}类型，因为该类型的变量必须具有不同的地址。
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 nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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

func Background() Context {
	return background
}

func TODO() Context {
	return todo
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// case 1:
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
DoSomeThing(ctx)

// case 2:
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
DoSomeThing(ctx)

// case 3:
deadline := time.Now().Add(3*time.Second)
ctx, cancel := context.WithDeadline(context.Background(), deadline)
defer cancel()
DoSomeThing(ctx)

1

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

1

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)

1

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

1
2
3
4

type canceler interface {
	cancel(removeFromParent bool, err error)
	Done() <-chan struct{}
}

1
2
3
4
5
6
7
8
9

// cancelCtx可以被取消，当它被取消时，也会取消实现了canceler接口的子ctx
type cancelCtx struct {
	Context

	mu       sync.Mutex            // 保护下面的字段，确保并发安全
	done     atomic.Value          // 懒加载创建的，它是一个 chan struct{} 类型的通道，在第一次调用取消函数时关闭。
	children map[canceler]struct{} // 第一次调用取消函数时置为nil
	err      error                 // 第一次调用取消函数是置为non-nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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 {
		// err不为空，说明之前就被取消了
		c.mu.Unlock()
		return // already canceled
	}
	// 给err赋值
	c.err = err
	d, _ := c.done.Load().(chan struct{})
	if d == nil {
		// 懒加载创建done
		c.done.Store(closedchan)
	} else {
		// 关闭d
		close(d)
	}
	for child := range c.children {
		// NOTE: acquiring the child's lock while holding parent's lock.
		// 将子ctx关闭
		child.cancel(false, err)
	}
	// 清楚父子ctx映射
	c.children = nil
	c.mu.Unlock()

	if removeFromParent {
		// 从父ctx移除
		removeChild(c.Context, c)
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
	// 参数校验
	if parent == nil {
		panic("cannot create context from nil parent")
	}
	// 创建一个cancelCtx的实例
	c := newCancelCtx(parent)
	// 该方法判断, 当传入的父ctx被取消时, 该cancelCtx也被取消
	propagateCancel(parent, &c)
	// 返回cancelCtx与它的cancel方法
	return &c, func() { c.cancel(true, Canceled) }
}

1
2
3
4
5
6
7

type timerCtx struct {
	cancelCtx
	// 受cancelCtx.mu的保护
	timer *time.Timer // Under cancelCtx.mu.

	deadline time.Time
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func (c *timerCtx) cancel(removeFromParent bool, err error) {
	// 直接调用cancelCtx取消ctx
	c.cancelCtx.cancel(false, err)
	if removeFromParent {
		// 从父ctx中移除
		removeChild(c.cancelCtx.Context, c)
	}
	c.mu.Lock()
	if c.timer != nil {
		// 将定时器关闭并置空
		c.timer.Stop()
		c.timer = nil
	}
	c.mu.Unlock()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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) {
		// 父ctx的deadline早于传入的d，直接构造无deadline的子ctx返回
		// 因为父ctx到deadline后，会自动将子ctx取消，这里无需构造两个timer了
		return WithCancel(parent)
	}
	// 构造timerCtx实例
	c := &timerCtx{
		cancelCtx: newCancelCtx(parent),
		deadline:  d,
	}
	// 父子关系绑定
	propagateCancel(parent, c)
	// 获取距离d还有多久，dur为time.Duration
	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 {
		// 启动子ctx的timer，在dur之后运行cancel方法。
		c.timer = time.AfterFunc(dur, func() {
			c.cancel(true, DeadlineExceeded)
		})
	}
	// 返回自身与cancel方法
	return c, func() { c.cancel(true, Canceled) }
}

1
2
3

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

1
2
3
4

type valueCtx struct {
	Context
	key, val any
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

func (c *valueCtx) Value(key any) any {
	// 如果传入的key等于valueCtx自身的key，则将自身的value返回
	if c.key == key {
		return c.val
	}
	// 自身没有对应的value，去父节点找
	return value(c.Context, key)
}

func value(c Context, key any) any {
	for {
		// 开启一个循环，判断c的类型
		switch ctx := c.(type) {
		case *valueCtx:
			// 父节点还是valueCtx，判断逻辑与上面一致
			if key == ctx.key {
				return ctx.val
			}
			// 寻找父节点的父节点
			c = ctx.Context
		case *cancelCtx:
			// 判断传入的key是否等于cancelCtxKey
			if key == &cancelCtxKey {
				return c
			}
			// 寻找父节点的父节点
			c = ctx.Context
		case *timerCtx:
			// 判断传入的key是否等于cancelCtxKey
			if key == &cancelCtxKey {
				return &ctx.cancelCtx
			}
			// 寻找父节点的父节点
			c = ctx.Context
		case *emptyCtx:
			// 空实现的ctx，直接返回nil
			return nil
		default:
			return c.Value(key)
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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}
}

1
2
3
4

1. Do not store Contexts inside a struct type; instead, pass a Context explicitly to each function that needs it. The Context should be the first parameter, typically named ctx.
2. Do not pass a nil Context, even if a function permits it. Pass context.TODO if you are unsure about which Context to use.
3. Use context Values only for request-scoped data that transits processes and APIs, not for passing optional parameters to functions.
4. The same Context may be passed to functions running in different goroutines; Contexts are safe for simultaneous use by multiple goroutines.