标准库 context Q&A
参考文档
context如何被取消
1. context.Context讲解
type Context interface {
// 返回context是否会被取消，以及自动取消时间
Deadline() (deadline time.Time, ok bool)
// 当context被取消了，或者到了最后的deadline, 返回一个被关闭的channel
Done() <-chan struct{}
// 在channel Done()关闭后，返回context取消原因
Err() error
// 获取key对应的value
Value(key interface{}) interface{}
}
2. Context是一个接口，定义了4个方法，它们都是幂等的，也就是说连续多次调用同一个方法，得到的结果是相同的
3. Done()返回一个channel, 可以表示context被取消的信号，当这个channel被关闭了，说明context被取消了
注意这里是一个只读的channel, 我们知道读取一个已关闭的channel，会读出响应类型的零值，并且源码里没有地方
会向这个channel塞入值，换句话说，这个一个read-only的channel，因此在子协程里读取这个channel，
除非被关闭，否则读取不出来任何东西, 也正是利用了这一点，子协程从channel中读出值（零值）后，就可以收尾退出了
4. Err() 返回一个错误，表示channel被关闭的原因，例如是被取消，还是超时
5. Deadline() 返回context的截止时间
6. Value() 获取之前设置的key对应的value
7. context.Background()通常用在main函数中，作为所有context的根节点
context.TODO()通常用在字并不知道传递什么context的情形，例如调用一个需要传递context的函数，
你手头并没有其它context可以传递，这时就可以传递TODO()，这常常发生在重构中，给一些函数添加了一个Context参数
但不知道要传递什么，就用TODO占个位子，最终要换成其他context
context是什么
1. go1.7标准库引入context,中文名就是"上下文", 准确说它是goroutine的上下文，包含goroutine的运行状态、环境、现场等信息
main goroutine 通知 child goroutine退出任务的案例
func main() {
messages := make(chan int, 10)
done := make(chan bool) // 创建一个无缓冲只读channel
go func() {
var ticker = time.NewTicker(time.Second)
for _ = range ticker.C{ // 遍历只读channel
select {
case <-done:
fmt.Println("main goroutine 通知 child goroutine结束了...")
return
default:
fmt.Println("messages: ", <-messages)
}
}
}()
for i := 0; i < 10; i++{
messages <- i
}
time.Sleep(time.Second * 5) // 主协程对上面的子协程有5秒的超时控制
close(done) // 关闭 channel
time.Sleep(time.Second)
fmt.Println("main goroutine 结束了...")
}
2. 上述例子中定义了一个buffer为0的channel done, 子协程运行这定时任务，如果主协程需要在某个时刻发送消息通知
子协程中断任务并退出，那么就可以让子协程监听这个done channel, 一旦主协程关闭done channel,那么子协程就可以
退出了，这样实现了主协程通知子协程的需求，但是还是有限的
3. 假如我们可以在简单的通知上附加额外的信息来控制取消，为什么取消，或者有一个它必须要完成的最终期限
更或者有多个取消选项，我们需要额外的信息来判断选择执行哪个取消选项
4. 考虑下面这种情况，假如主协程有多个任务，1，2，m，主协程对这些任务有超时控制，
而其中任务1又有多个子任务1,2，n, 任务1对这些子任务也有超时控制，
那么这些子任务即要感知主协程的取消信号，也要感知任务1的取消信号，
5. 如果还是使用done channel的方法，我们需要定义两个done channel, 子任务需要监听这两个done channel
这样好像也还行，但是如果层级更深的话，这些子任务还有子任务的话，那么使用done channel的方法将变得非常繁琐且混乱
6. 我们需要优雅的方案来实现这一种机制：
* 上层任务取消后，所有的下层任务都会被取消
* 中间某一层任务取消后，只会将当前任务的下层任务全部取消，而不会影响上层任务及同级任务
这个时候，context就派上用场了
7. Context接口包含四个方法：
Deadline返回绑定当前context的任务被取消的截止时间；如果没有设定期限，将返回ok == false。
Done 当绑定当前context的任务被取消时，将返回一个关闭的channel；如果当前context不会被取消，将返回nil。
Err 如果Done返回的channel没有关闭，将返回nil;如果Done返回的channel已经关闭，将返回非空的值表示任务结束的原因。如果是context被取消，Err将返回Canceled；如果是context超时，Err将返回DeadlineExceeded。
Value 返回context存储的键值对中当前key对应的值，如果没有对应的key,则返回nil。
8. 可以看到Done()方法返回的channel用来传递结束信号以中断当前任务，
Deadline()方法指示一段时间后当前goroutine是否会被取消，
以及一个Err()方法用来解释goroutine被取消的原因，而Value用于获取当前任务树的额外信息，
9. Background()方法和TODO()方法生成的context其实是一致的，那么我们何时调用哪个呢
background通常用于主函数、初始化、以及测试中使用，作为一个顶层的context,
也就是说一般我们创建的context都是基于bakground
TODO()是在不确定使用什么context的时候使用
两种不同功能的基础context类型，valueCtx、cancelCtx
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)
}
1. valueCtx嵌入了Context变量来表示父节点context,表示当前context继承了父context的所有信息
valueCtx还携带了一组键值对，也就是说这种context可以携带额外的信息，valueCtx实现了Value方法
用以在context链路上获取key对应的值，如果当前context不存在需要的key，会沿着context链向上
寻找key对应的值，直到根节点
WithValue
1. WithValue用以向context添加键值对，
func WithValue(parent Context, key, val interface{}) 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}
}
2. 这里添加键值对不是在原结构体上直接添加，而是以此context作为父节点，重新黄建一个valueCtx子节点
将键值对添加到子节点上，由此形成一条context链，获取value的过程就是在此context链上由尾部向前搜索
cancelCtx
type cancelCtx struct {
Context
mu sync.Mutex // protects following fields
done atomic.Value // of chan struct{}, created lazily, closed by first cancel call
children map[canceler]struct{} // set to nil by the first cancel call
err error // set to non-nil by the first cancel call
}
1. cancelCtx跟valueCtx类似，cancelCtx结构体中也有一个变量context作为父节点，
变量done表示一个channel, 用来表示传递关闭信号，children表示一个map，用来存储当前context节点下的子节点
err存储错误信息表示被取消的原因
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 {
c.mu.Unlock()
return // already canceled
}
// 设置取消原因
c.err = err
d, _ := c.done.Load().(chan struct{})
// 设置一个关闭的channel或者将done channel关闭，用以发送关闭的信号
if d == nil {
c.done.Store(closedchan)
} else {
close(d)
}
// 将子节点context依次取消
for child := range c.children {
// NOTE: acquiring the child's lock while holding parent's lock.
child.cancel(false, err)
}
c.children = nil
c.mu.Unlock()
// 将当前context节点从父节点上移除
if removeFromParent {
removeChild(c.Context, c)
}
}
2. 可以发现cancelCtx类型的变量其实也是canceler类型，因为cancelCtx实现了canceler接口，
Done()方法返回的是通知goroutine取消的信号通道，Err()方法返回的是被取消的原因
cancelCtx类型的context在调用cancel方法时，会设置取消原因，将done channel设置为一个关闭的channel
或者关闭channel, 然后将子节点context依次取消，如果有需要还会将当前节点从父节点直接移除
WithCancel
1. WithCancel函数用来创建一个可取消的context, 即cancelCtx类型的context,
WithCancel()方法返回一个cancelCtx和CancelFunc, 调用CancelFunc即可触发cancel操作，看源码
type CancelFunc func()
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
if parent == nil {
panic("cannot create context from nil parent")
}
c := newCancelCtx(parent)
propagateCancel(parent, &c)
return &c, func() { c.cancel(true, Canceled) }
}
TimerCtx
1. timerCtx是一种基于cancelCtx的context类型，从字面上就可以看出，这是一种可以定时取消的context类型
timerCtx增加了两个字段，timer和deadline， timer:计时器，deadline:截止日期
2. timerCtx内部使用cancelCtx实现取消，另外使用定时器timer和过期时间deadline实现定时取消的功能，
timerCtx在调用cancel方法时，会先将内部的cancelCtx取消，如果需要则将自己从cancelCtx祖先节点上移除
最后取消计时器
WithDeadline
1. 如果父节点parent有过期时间，并且过期时间<设置的时间d,那么新建的子节点context无须设置过期时间
使用WithCancel创建一个可取消的context即可
2. 否则就利用parent和过期时间d创建一个定时取消的timerCtx, 并建立context与可取消context祖先节点的
取消关联关系，接下来判断当前时间具体过期时间d的时长dur
3. 如果dur<0,表明当前已经过了过期，则直接取消新的timerCtx
4. 为新建的timerCtx设置定时器，一旦达到过期时间就取消当前的timerCtx
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
if parent == nil {
panic("cannot create context from nil parent")
}
// 如果父节点parent有过期时间，并且过期时间<设置的时间d,那么新建的子节点context无须设置过期时间
// 使用WithCancel创建一个可取消的context即可
if cur, ok := parent.Deadline(); ok && cur.Before(d) {
// The current deadline is already sooner than the new one.
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()
// 为新建的timerCtx设置定时器，一旦达到过期时间就取消当前的timerCtx
if c.err == nil {
c.timer = time.AfterFunc(dur, func() {
c.cancel(true, DeadlineExceeded)
})
}
return c, func() { c.cancel(true, Canceled) }
}
WithTimeout
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
return WithDeadline(parent, time.Now().Add(timeout))
}
1. 与WithDeadline类似，WithTimeout也是创建一个定时取消的context,只不过WithDeadline是接收一个过期时间点
而WithTimeout是接收一个过期时长，看源码也知道，WithTimeout也是调用的WithDeadline
Context的使用
1. 使用context实现文章开头done channel的例子示范一下如何更优雅的实现协程间取消信号的同步
func main() {
messages := make(chan int, 10)
for i := 0; i < 10; i++{
messages <- i
}
// 创建带过期时间的context
ctx, cancel := context.WithTimeout(context.Background(), time.Second * 5)
go func(ctx context.Context) {
ticker := time.NewTicker(time.Second)
for _ = range ticker.C{ // 遍历通道，一秒执行一次
select{
case <-ctx.Done():
fmt.Println("child goroutine 结束了...")
return
default:
fmt.Println("receive message: ", <-messages)
}
}
}(ctx)
defer close(messages)
defer cancel() // 此语句可以省略，因为context是带过期时间的，不需要手动取消
select{
case <-ctx.Done():
time.Sleep(time.Second)
fmt.Println("main goroutine 结束了")
}
}
2. 这个例子中，只要让子协程监听主协程传入的ctx，一旦ctx.Done()方法返回空channel, 子线程即可取消执行任务
但是这个例子还无法展现context的传递取消信息的强大优势
3. net/http包的源码里在实现http server就用到了context, 简单分析下
4. 重点：
这样处理的目的主要有以下几点：
1. 一旦请求超时，即可中断当前请求；
2. 在处理构建response过程中如果发生错误，可直接调用response对象的cancelCtx方法结束当前请求；
3. 在处理构建response完成之后，调用response对象的cancelCtx方法结束当前请求。
* 在整个server处理流程中，使用了一条context链贯穿Server、Connection、Request，不仅将上游的信息共享给下游任务，
* 同时实现了上游可发送取消信号取消所有下游任务，而下游任务自行取消不会影响上游任务。
context是什么？
1. context主要用来在goroutine之间传递上下文信息，包括取消信号，超时时间，截止时间，k-v等
2. 随着context包的引入，标准库中很多接口也增加了context参数，例如database/sql,
context几乎成为了并发控制和超时控制的标准做法
context有什么用？
1. go通常用来写后台服务，只需要几行代码就可以写一个http server,在go的server里
通常每来一个请求都会启动若干个goroutine同时工作，有些去数据库拿数据，有些调用下游接口获取相关数据
这些goroutine需要共享这个请求的基本数据，例如登录的token，处理请求的最大超时时间
当请求被取消或者超时，所有为这个请求工作的goroutine需要快速退出，系统就可以回收相关资源
2. go语言中的server实际上是一个"协程模型", 也就是说一个协程处理一个请求，例如业务高峰期，某个下游服务器响应变慢
而当前系统的请求又没有超时控制，或者说超时时间设置的过大，那么等待下游服务器返回数据的协程会越来越多，
协程也是需要消耗资源的，如果携程数量激增，内存暴涨，甚至导致服务不可用，更严重会导致雪崩效应，整个服务对外不可用，P0级别的事故
3. 上面说的P0级别事故，可以通过设置下游服务器最大处理时间就可以避免，给下游服务器设置timeout=5ms,
如果这个时间没有接收到数据，就直接返回给客户端一个默认值或错误，
4. context包就是为了解决上面这些问题而开发的，在一组goroutine之间传递共享的值，取消信号，超时控制，截止日期
5. 用简练的话来说，在go里面，我们不能直接杀死协程，需要通过channel+select的方法来关闭协程，
但是在某些场景下，例如一个请求衍生了很多个协程，这些协程间是相互关联的，需要共享一些全局变量，有共同的deadline
而且可以同时被关闭，再用channel+select就会比较麻烦，这是就可以通过context来实现
* 一句话解决：context用来解决goroutine之间 退出通知、元数据传递 的功能
6. 【引申1】举例说明context在实际项目中如何使用
context会在函数传递间传递，只需要在适当的时间调用cancel函数就可以向goroutine发出取消信号
或者调用Value函数取出context中的值
7. context使用注意4个事项
1. 不要将context塞入结构体里，直接将context作为函数的第一参数，而且一般命名为ctx
2. 不要向函数传入一个nil context,如果你是在不知道传递什么，标准库给提供好了一个context:todo
3. 不要把本应该作为函数参数的类型放入到context中，context应该存储一些共同的数据，例如登录的session、cookie等
4. 同一个context有可能会被传入到多个goroutine,别担心，context是并发安全的
context可以传递共享的数据
1. 对于web服务端开发，往往希望将一个请求处理的整个过程串起来，这非常依赖于Thread Local(对于go可以理解为单个协程所独有的)
变量，go语言中没有Thread Local这个概念，所以在调用函数是需要传递context
func main() {
bgCtx := context.Background()
process(bgCtx)
vCtx := context.WithValue(bgCtx, "traceId", "123456")
process(vCtx)
}
func process(ctx context.Context){
if traceId, ok := ctx.Value("traceId").(string); ok{
fmt.Printf("process over, traceId = %s\n", traceId)
} else {
fmt.Println("process over, no traceId")
}
}
/*
process over, no traceId
process over, traceId = 123456
*/
context可以信号通知取消goroutine
1. 设想一个场景，打开外卖订单，上面显示外卖小哥的位置，而且每秒更新一次，app向后端发起websocket链接后，
后台启动一个协程，每隔一秒计算一次小哥的位置并发送给前端，如果用户退出订单页面，后台需要取消此过程，
退出goroutine,系统回收资源
func Perform(ctx context.Context) {
for {
calculatePos()
sendResult()
select {
case <-ctx.Done():
// 被取消，直接返回
return
case <-time.After(time.Second):
// block 1 秒钟
}
}
}
ctx, cancel := context.WithTimeout(context.Background(), time.Hour)
go Perform(ctx)
// ……
// app 端返回页面，调用cancel 函数
cancel()
2. 注意一个细节，WithTimeout函数返回的context和cancel是分开的，context本身并没有取消函数，
这样做的原因是取消函数只能由外层函数调用，防止子节点contxt调用取消函数，从而严格控制信息的流向
由父节点context流向子节点context
防止goroutine泄漏
1. 举一个例子，如果不用context取消，goroutine就会泄漏的例子
func gen() <-chan int {
ch := make(chan int)
var n int
go func() {
for {
ch <- n
n++
time.Sleep(time.Second)
}
}()
return ch
}
func main() {
for v := range gen(){
fmt.Println(v)
if v == 5{
break
}
}
time.Sleep(time.Second * 5)
}
2. 这是一个可以无限生成整数的协程，但如果我们只要产生的前5个数，那么就会发生goroutine泄漏
当n == 5, 直接break掉，那么gen函数的协程就会执行无限循环，发生了goroutine泄漏
3. 用context改进这个例子
func gen(ctx context.Context) <-chan int {
ch := make(chan int)
go func() {
var n int
for {
select{
case <-ctx.Done(): // 监听主协程发出的退出信号
return
case ch <- n:
n++
time.Sleep(time.Millisecond * 200)
}
}
}()
return ch
}
func main() {
cancelCtx, cancelFunc := context.WithCancel(context.Background())
defer cancelFunc() // 避免其它地方忘记cancel,并且重复调用不影响
for v := range gen(cancelCtx){
fmt.Println(v)
if v == 5{
cancelFunc() // 取消所有子协程, 然后退出循环
break
}
}
}
4. 增加一个context, 在break前调用cancel函数，取消子goroutine, gen()函数在接收到取消信号后，
直接退出，系统回收资源
context.Value的查找过程是怎样的
type valueCtx struct {
Context
key, val interface{}
}
func (c *valueCtx) String() string {
return contextName(c.Context) + ".WithValue(type " +
reflectlite.TypeOf(c.key).String() +
", val " + stringify(c.val) + ")"
}
func (c *valueCtx) Value(key interface{}) interface{} {
if c.key == key {
return c.val
}
return c.Context.Value(key)
}
1. 由于它直接将Context作为匿名字段，因此尽管它只实现了两个方法String()和Value()，其它方法继承自Context
但它仍然是一个context,这是go语言的一个特点
2. 创建valueCtx函数：
func WithValue(parent Context, key, val interface{}) 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}
}
3. 对key的要求是可比较，因为之后要通过key取出context中的值，可比较是必须的,通过层层传递context,
最终形成一棵树
4. 和链表有点像，只是它的方向相反，Context指向它的父节点，而链表指向下一个节点，
通过WithValue函数可以创建层层的valueCtx，存储goroutine间可以共享的变量,
取值的过程，实际上是一个递归查找的过程
func (c *valueCtx) Value(key interface{}) interface{} {
// 取值的过程，实际上是一个递归查找的过程，先从当前valueCtx中的key查找
// 如果不存在就从它的父节点的Context中去查找，层层递归，直到找到或nil为止
if c.key == key {
return c.val
}
return c.Context.Value(key)
}
5. 它会顺着链路一直往上找，比较当前节点的key是否是要查找的key，如果是，则直接返回value,
否则一直顺着context往前，最终找到根节点（一般是emtpyCtx),直接返回一个nil,
所以用Value方法的时候要判断，结果是否为nil
6. 因为查找方向是往上走的，所以父节点没法获取子节点的值，子节点却可以获取父节点的值，
7. WithValue: 创建context节点的过程实际上就是创建链表节点的过程，两个节点的key值是可以相等的，
但他们是两个不同的context节点，查找的时候会先从当前节点查找，如果找不到一直找到最后根节点，
整体而言，用WithValue构造的其实是一个低效率的链表
8. 注意：如果能用函数参数传递的尽量不要使用context传参，context尽量传递一些共享的变量如session,cookie等
