go context专题（三）- context 工作机制和代码分析

talk is cheap show me the code

源码分析context的工作机理

下面我写的一段简单的实验性质的代码，简单的阐述一下context库的最基本的用法。

package main

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

/*
Author: andes
Date  :	20170821
*/

//define a new type include a Context Field
type otherContext struct {
context.Context
}

func main() {

//Construct a *cancelCtx type object
ctxa, cancel := context.WithCancel(context.Background())
go work(ctxa, "work1")

//Construct a *timerCtx type object wrapped by *cancelCtx
tm := time.Now().Add(3 * time.Second)
ctxb, _ := context.WithDeadline(ctxa, tm)
go work(ctxb, "work2")

oc := otherContext{ctxb}
//Construct a *cancelCtx type object wrapped by oc
ctxc := context.WithValue(oc, "key", "god andes,pass from main ")
go workWithValue(ctxc, "work3")

time.Sleep(10 * time.Second)
cancel()
time.Sleep(5 * time.Second)
fmt.Println("main stop")
}

//do something
func work(ctx context.Context, name string) {
for {
select {
case <-ctx.Done():
fmt.Printf("%s get msg to cancel\n", name)
return
default:
fmt.Printf("%s is running \n", name)
time.Sleep(1 * time.Second)
}
}
}

//do something and pass values by context
func workWithValue(ctx context.Context, name string) {
for {
select {
case <-ctx.Done():
fmt.Printf("%s get msg to cancel\n", name)
return
default:
value := ctx.Value("key").(string)
fmt.Printf("%s is running value=%s \n", name, value)
time.Sleep(1 * time.Second)
}
}
}

运行结果



程序分析：

使用context封装的过程中，程序在底层实际上维护了两条关系链，理解这个关系链才是真的懂context包：

两条引用关系链分别是：
一条是  children key构成的从根到叶子的Context实例的引用关系，这个关系在调用With函数时进行维护（调用func propagateCancel(parent Context, child canceler) 函数维护）

上面程序有一层这样的树形结构（本示例是个链）：
 ctxa.children --->ctxb  
   ctxb.children--->ctxc
这个树的作用：提供一种从根可以遍历到叶子的方法，context包的取消广播通知的核心就是基于这一点。
反正这条链是从树根像下层逐层广播下去，当然你也可以在任意一个子树上调用取消通知，一样会扩散到整棵树。
ctxa收到退出通知，会通知到其绑定goroutine work1，同时也会广播给ctxb和ctxc绑定的goroutines work2 work3
同理：ctxc 收到退出通知，会通知到绑定的goroutine work2，同时也会广播给ctxc绑定的goroutine work3

一条是在构造Context的对象中不断的包裹Context实例所形成的一个引用关系链，从外到内的引用
 ctxc.Context -->oc
 ctxc.Context.Context -->ctxb
 ctxc.Context.Context.cancelCtx  -->ctxa
 ctxc.Context.Context.cancelCtx.Context -->new(emptyCtx)  //context.Background()
这个关系什么用，很简单为了切断和上层的Context的实例之间的关系,比如ctxb自己取消了自己(定时器），没有必要在退出通知广播链上继续存在，就找到parent，然后执行 delete(parent.children,ctxb)，就把自己从广播链条上释放掉。

看上面如果有困难，可以看下核心代码的解读

ctxa, cancel := context.WithCancel(context.Background())
/*
ctxa内部状态---->ctxa=&cancelCtx {
Context: new(emptyCtx)
}
*/
go work(ctxa, "work1")
tm := time.Now().Add(3 * time.Second)
ctxb, _ := context.WithDeadline(ctxa, tm)
/*
ctxb内部状态--->
ctxb=&timerCtx{
cancelCtx: ctxa
dataline:tm
}
同时触发ctxa的children维护到ctxb的关系
*/

go work(ctxb, "work2")

oc := otherContext{ctxb}
ctxc := context.WithValue(oc, "key", "pass from main ")
/*
ctxc--->ctxc=&cancelCtx {
Context: oc
}
同时通过oc.Context找到ctxb,通过ctxb.cancelCtx找到ctxa,在ctxa的children字段中维护ctxc
*/
go workWithValue(ctxc, "work3")

context 使用过程中参与角色

通知发起goroutine

负责创建Context对象并且把Context对象传递给后端新起的goroutine

在请求期结束其要负责调用Context对象的cancel方法通知后端goroutine释放资源

后端接收通知goroutine

后端每一个接受Context的goroutine可以继续使用WithCancel, WithDeadline, WithTimeout, or WithValue 包装这个Context，然后传向后端

在处理正确逻辑的过程中，要注意监听是否收到退出通知，后端调用链里面的所有的goroutine要增加监听退出通知的逻辑

context 使用通用模式

1.创建一个原始的Context实例对象
func Background() Context 
unc TODO() Context

2.包装上一步创建的Context对象，使其具有特定的功能

    //这个函数是context package的核心，几乎所有的封装都是从其开始，原因很简单：我们使用context的包的核心就是使用其退出通知广播功能，如果不从其开始构造，

    说明我们的使用已经偏离的context包设计的初衷。
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
func WithValue(parent Context, key, val interface{}) Context

3.每一层goroutine可以继续封装Context对象，封装自己需要的功能

4.最上层的goroutine负责在一个请求处理完后及时的调用cancel函数，通知后端的goroutine释放资源

5.后端的goroutine 要负责监听Context.Done() 返回chan,及时的退出并且释放资源

整个调用栈如下图