Skip to content

Latest commit

 

History

History

context

Folders and files

NameName
Last commit message
Last commit date

parent directory

..
 
 

context

context 应该被翻译为上下文,但是 go 语言中的 context 更多的作用是取消子 goroutine,传递信息这个上下文本来的含义,在 go 的 context 反而不是重点

context 本身是一个接口类型,它拥有四个方法:

  • Deadline()(deadline time.Time,ok bool):返回一个代表此上下文完成工作的时间,如果没有截止时间,返回 false
  • Done() <-chan struct {}:代表了完结
  • Err() error:如果 context 已经 done 了返回一个 error 错误,错误值分别为:Canceled,DeadlineExceeded,如果没有 done,error 返回 nil
  • Value(key any) any:context 中存储的键值对

context 作为上下文,需要一个最顶层的 context 接口类型,你可以使用 context.Background() 或者 context.TODO() 去充当这个顶端,这两者是一个意思,用哪个都可以,这是 go 提供的已经实现了 context 接口类型的对象,它的底层是一个结构体

context 有一些编程范式:

  • 将 cotext 设置为参数的第一个,例如 func age(ctx context.Context,a string)
  • 不要使用 nil 作为上下文参数,如果想要空的顶端上下文,使用 context.Background,虽然 background 底层实现接口的时候,也是内容为空,但是它的确是实现了接口
  • context 只能作为函数的临时传递对象,不能持久化它,使用数据库保存,等持久化方式都是不可取的
  • 使用 withValue 方法的时候,key 值不要使用 string,如果起冲突,使用自建的类型,例如 type A struct{}
  • 尽量不要定义输出的 key 值

使用 context

标准库中提供了多个 context 接口类型实例:

  • WithCancel
  • WithCancelCause
  • WithDeadline
  • WithDeadlineCause
  • WithTimeout
  • WithTimeoutCause

其中,带有 Cause 的函数跟不带的函数基本意思相同,但是多了一个 cause 的内容,它是指的是取消的原因

withValue

WithValue 基于 parent Context 生成一个新的 Context,保存了一个 key-value 键值 对。它常常用来传递上下文。

context 在查询 key 值的时候还支持链式查找,如果没有发现数据就往 parent context 中查询

ctx = context.TODO()
ctx = context.WithValue(ctx, "key1", "0001")
ctx = context.WithValue(ctx, "key2", "0001")
ctx = context.WithValue(ctx, "key3", "0001")
ctx = context.WithValue(ctx, "key4", "0004")
fmt.Println(ctx.Value("key1"))

WithCancel

withCancel 返回父 context 中的 ctx 实例副本,它相当于父 context 的子 context,并且在父 context 被取消时,子 context 也会被取消。

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

propagateCancel 部分代码:

func (c *cancelCtx) propagateCancel(parent Context, child canceler) {
	c.Context = parent

	done := parent.Done()
	if done == nil {
		return // parent is never canceled
	}

	select {
	case <-done:
		// 如果父done了,那么子ctx一定也会出发cancel
		child.cancel(false, parent.Err(), Cause(parent))
		return
	default:
	}

	if p, ok := parentCancelCtx(parent); ok {
		// parent is a *cancelCtx, or derives from one.
		p.mu.Lock()
		if p.err != nil {
			// 如果父发生了cancel,那么子ctx也要触发cancel
			child.cancel(false, p.err, p.cause)
		} else {
			if p.children == nil {
				p.children = make(map[canceler]struct{})
			}
      // 将子ctx添加到父ctx中
			p.children[child] = struct{}{}
		}
		p.mu.Unlock()
		return
	}
  ...
  go func() {
		select {
      // 父 done被触发,那么子ctx就会被触发cancel操作
		case <- parent.Done():
			child.cancel(false, parent.Err(), Cause(parent))
		case <-child.Done():
		}
	}()
}

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

propagateCancel 将 c 向上传播,顺着 parent 的路径一直向上查找,直到找到 parentCancelCtx,如果不为空,就把自己加入到这个 parentCancelCtx 的 children 切片中,然后就可以在父 ctx 取消的时候,通知自己也被取消

当这个 cancelCtx 的 cancel 函数被调用的时候,parent 的 Done 被 close 的时候,或者父 ctx 触发了 cancel 的时候,这个子 ctx 会被触发 cancel 动作

cancel 是向下传递的,如果一个 WithCancel 生成的 Context 被 cancel 时,如果它的子 Context (也有可能是孙,或者更低),就会被 cancel,但是不会向上传递。parent Context 不会因为子 Context 被 cancel 而 cancel。

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	go func() {
		for {
			select {
			case <-ctx.Done():
				fmt.Println("done")
			}
		}
	}
  time.Sleep(time.Second * 10)
}

WithCancel 返回 parent context 的一个副本,它自然就是子 context,当父 context 被 cancel 的时候,子 context 也会被 cancel

withTimeout withDeadline

这两个只是添加了到期时间,一个是超时时间,一个是截止时间,一旦超过时间后,自动 close 这个 done 这个 channel

综上所述,done 这个 channel 被 close 有三个原因:

  • 截止时间到了
  • cancel 函数被调用了
  • parent context 的 done close 了,然后子 ctx 也要触发 cancel 方法
  • parent context cancel 了触发子 ctx cancel 方法

关于第三条,解释一下:(第四条类似)

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	// 创建一个父context,设置deadline为3秒
	parentCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 创建一个子context,deadline继承父context
	childCtx, cancel := context.WithCancel(parentCtx)
	defer cancel() // 注意这里需要调用cancel

	go doWork(childCtx)

	time.Sleep(14 * time.Second)
}

func doWork(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
		   // 工作代码
			fmt.Println("over")
			return
	//default:
	//	fmt.Println("default")
		}
	}
}

在使用 select 监听 Context 的 Done 通道时,最好不要使用 default 分支。

原因有以下几点:

  • default 分支会导致无法准确检测到 Context cancellation 的信号,如我们之前分析的那样
  • 使用 default 时需要仔细设计 case 分支的阻塞时间,比较 tricky
  • 不使用 default 可以确保每次 select 都会阻塞,从而能捕捉到外部的取消通知
  • 默认情况下,不使用 default 也可以使代码更简洁

带有 cause 的函数

我们看一个例子

package main

import (
	"context"
	"errors"
	"fmt"
)

func main() {
	var myError = errors.New("myError")
	ctx, cancel := context.WithCancelCause(context.TODO())
	cancel(myError)
	ctx.Err()                       
	fmt.Println(context.Cause(ctx)) // returns myError
}

但我们调用 cancel 函数的时候,内部参数是一个 error 类型,调用 context.Cause(ctx) 返回的就是它的取消原因,那么这里的话就是 MyError

在 WithTimeout 中 cancel() 函数的存在意义是什么?

cancel 函数的作用是可以手动提前取消 Context,使其 Done channel 关闭,不用等待 timeout 的时间或者 deadline 的时间

所以 cancel 函数相当于手动取消的意思,并不是说有了 timeout deadline 之后,cancel 函数就没有存在的意义了。

按照 go 的语法,即便是 timeout 触发了 <- done 操作,你仍然需要手动的去在最后调用 cancel 函数,否则就会报错

WithTimeout 在超时时会自动 cancel context,但是 cancel 函数还是需要调用,以释放/重置 Context 内部的 timer,如果不调用 cancel,timer 不会被释放,持续运行并重复 cancel 导致 context leak,占用更多资源。

ctx, cancel := context.WithTimeout(parentCtx, 2*time.Second)

go doWork(ctx) 

// 1秒后决定取消任务
time.Sleep(1*time.Second)  
cancel()

issues

contex.Contex 如何实现并发安全的?

Go 语言中 context 实现并发安全的主要手段是通过原子操作和 Mutex 来保证状态的原子性

根据底层代码可知,当不同的 goroutine 获取 ctx 的时候,每次操作都会加上互斥锁,来保证数据的非竞争性,线程的安全,例如

if p, ok := parentCancelCtx(parent); ok {
		// parent is a *cancelCtx, or derives from one.
		p.mu.Lock()
		if p.err != nil {
			// 如果父发生了cancel,那么子ctx也要触发cancel
			child.cancel(false, p.err, p.cause)
		} else {
			if p.children == nil {
				p.children = make(map[canceler]struct{})
			}
      // 将子ctx添加到父ctx中
			p.children[child] = struct{}{}
		}
		p.mu.Unlock()
		return
	}