阅读 515

Golang | 一文带你深入context

前言

首先解答上一篇文章一文带你快速入门context中留下的疑惑,为什么要defer cancelFunc()

func main() {
	parent := context.Background()
	for i := 0; i < 100; i++ {
		go doRequest(parent)
	}
	time.Sleep(time.Second * 10)
}

// doRequest 模拟网络请求
func doRequest(parent context.Context) {
	ctx, _ := context.WithTimeout(parent, time.Second*5)
	time.Sleep(time.Millisecond * 200)
	go func() {
		<-ctx.Done()
		fmt.Println("ctx done!")
	}()
}
复制代码

看上面的代码,在main函数中异步调用doRequest函数,doRequest函数中新建一个5s超时的上下文,doRequest函数的调用时长为200ms

image-20210710222940035

可以看到,doRequest的上下文时间范围远大于函数调用花费的时间,在函数结束后没有主动取消上下文,这会造成上下文泄露

所以,defer cancelFunc()的目的是避免上下文泄露!!

主动调用cancelFunc是一个好习惯!

了解一下Context接口

type Context interface {
    // [1] 返回上下文的截止时间
    Deadline() (deadline time.Time, ok bool)
    // 返回一个通道,当上下文结束时,会关闭该通道,此时 <-ctx.Done() 结束阻塞
    Done() <-chan struct{}
    // [2] 该方法会在上下文结束时返回一个not nil err,该err用于表示上下文结束的原因
    Err() error
    // 返回与key关联的上下文的value
    Value(key interface{}) interface{}
}
复制代码

[1]处,当上下文没有设置截止时间时,调用Deadline,返回结果值中,ok = false

func main() {
	ctx, cancelFunc := context.WithCancel(context.Background())
	defer cancelFunc()
	deadline, ok := ctx.Deadline()
	fmt.Printf("ok = %v, deadline = %v\n", ok, deadline)
	// 输出 ok = false, deadline = 0001-01-01 00:00:00 +0000 UTC
}
复制代码

[2]处,即使主动取消上下文,Err返回值not nil

func main() {
    ~~//~~ 设置上下文10s的超时时间
	ctx, cancelFunc := context.WithTimeout(context.Background(), time.Second * 10)
	go func() {
		// 1s后主动取消上下文
		<-time.After(time.Second)
		cancelFunc()
	}()
	<-ctx.Done()
	err := ctx.Err()
	fmt.Printf("err == nil ? %v\n", err == nil)
	// 输出 err == nil ? false
}
复制代码

有几个结构体不能错过

看完Context接口后,我们来了解一下context包中预定义的4种上下文对应的结构体

image-20210710231150954

可以看到,4种上下文分别对应3种结构体,超时上下文和截止时间上下文底层使用都是timerCtx

然后,来看看这3种结构体当中有什么属性,以及它们是如何实现Context接口

cancelCtx

type cancelCtx struct {
	Context // [1] 匿名接口

	mu       sync.Mutex            // 这个锁是用来保护下面这些字段的
	done     chan struct{}         // [2] 这个channel的初始化方式为懒加载
	children map[canceler]struct{} 
	err      error                 
}

// 新建可取消的上下文
func newCancelCtx(parent Context) cancelCtx {
	return cancelCtx{Context: parent}
}

func (c *cancelCtx) Value(key interface{}) interface{} {
	if key == &cancelCtxKey {
		return c
	}
  // 搜索父级上下文的value
	return c.Context.Value(key)
}

func (c *cancelCtx) Done() <-chan struct{} {
	c.mu.Lock()
	if c.done == nil {
    // 懒加载,第一次调用Done方法的时候,channel才初始化
		c.done = make(chan struct{})
	}
	d := c.done
	c.mu.Unlock()
	return d
}

func (c *cancelCtx) Err() error {
	c.mu.Lock()
	err := c.err
	c.mu.Unlock()
	return err
}
复制代码

[1]处,可以看到cancelCtx嵌入了一个匿名接口

构建cancelCtx结构体时,使用父级上下文parent作为结构体匿名接口的实现

同时结构体中重写了匿名接口中的3个方法,分别是ValueDoneErr

所以,当调用cancelCtx中的Deadline方法时,实际上是调用parentDeadline方法

[2]处,结构体中表示上下文结束的done通道是懒加载的形式初始化,会在首次调用Done方法的时候,初始化done通道

timerCtx

type timerCtx struct {
	cancelCtx // [1] 内嵌结构体
	timer *time.Timer // [2] 用于实现截止时间

	deadline time.Time
}

func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
	return c.deadline, true
}

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
  // 构建超时上下文底层也是通过构建截止时间上下文
	return WithDeadline(parent, time.Now().Add(timeout))
}

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
	if cur, ok := parent.Deadline(); ok && cur.Before(d) {
		// 当子上下文的截止时间超过父级上下文时,直接构造可取消的上下文并返回
		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) }
}
复制代码

[1]处可以看到,timerCtx内嵌cancelCtx结构体,所以构建timerCtx时,也是接受父级上下文parent作为其内嵌接口的实现,而且timerCtx只重写Deadline方法

[2]处可以看到,上下文的截止时间的控制本质就是通过timer定时器控制,通过timer.AfterFunc实现在指定时间cancel掉上下文

valueCtx

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

func (c *valueCtx) Value(key interface{}) interface{} {
	if c.key == key {
		return c.val
	}
	return c.Context.Value(key) // 寻找父级上下文中是否包含与该key关联的值
}

func WithValue(parent Context, key, val interface{}) Context {
	if key == nil {
		panic("nil key")
	}
  // [1] 存入key的类型是不可比较时直接panic
	if !reflectlite.TypeOf(key).Comparable() {
		panic("key is not comparable")
	}
	return &valueCtx{parent, key, val}
}
复制代码

valueCtx整体还是前两个结构体更为简单,父级上下文parent只重写了Value方法

主要关注的地方是[1]处什么类型是不可比较的?

  • slice
  • map
  • func

这三种类型是不可以比较的,也就是将切片、map或者函数作为valueCtxkey是会导致程序panic的!!

思考以下几个问题

上下文中的通道为什么要懒加载?

我的猜测是节省内存

首先,不管是主动取消还是定时结束上下文,都会调用到cancel函数

函数中会判断,此时上下文的通道是否为空,如果为空,则使用一个全局变量closedchan,这个通道是在包初始化阶段就close

// 这是一个可重复使用的通道
var closedchan = make(chan struct{})

func init() {
  // 包初始化时,关闭通道
	close(closedchan)
}

func (c *cancelCtx) cancel(removeFromParent bool, err error) {
  ....
  if c.done == nil {
    // 如果done为空,就代表当前还没调用过Done方法,则直接使用closechan替代
		c.done = closedchan
	} else {
		close(c.done)
	}
  ....
}
复制代码

上下文的使用不一定都需要调用Context.Done方法

通过可重复使用的closedchan,避免了在构建上下文的过程中立马初始化done通道,减少了一些不必要的内存分配

多次调用cancelFunc会怎么样?

并不会怎么样,多次主动取消上下文不会产生任何错误

调用cancelFunc时,底层调用cancel函数,函数中会判断当前上下文是否已经结束,如果已经结束了则直接return

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 
	}
  ...
}
复制代码
img

当前上下文的截止时间能否超过父级上下文的截止时间?

不能,此时上下文的截止时间会跟父级上下文的截止时间保持一致

可以看到,WithDeadline函数中,第一步就校验了截止时间

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
	if cur, ok := parent.Deadline(); ok && cur.Before(d) {
		// 当子上下文的截止时间超过父级上下文时,直接构造可取消的上下文并返回
		return WithCancel(parent)
	}
  ....
}
复制代码

当返回一个可取消的上下文时,表示子上下文的截止时间跟父级上下文是一致的

background和todo的区别是什么?

本质上并没有任何区别,底层都是使用emptyCtx构造的,主要的区别在于使用语义上

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

func Background() Context {
	return background
}

func TODO() Context {
	return todo
}
复制代码

当不确定要传什么上下文的时候,就选择TODO,不过通常这种情况都应该是暂时性的

文章分类
后端
文章标签