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

talk is cheap show me the code

源码分析context的工作机理

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

package mainimport ("context""fmt""time")/*Author: andesDate  :20170821*///define a new type include a Context Fieldtype otherContext struct {context.Context}func main() {//Construct a *cancelCtx type objectctxa, cancel := context.WithCancel(context.Background())go work(ctxa, "work1")//Construct a *timerCtx type object wrapped by *cancelCtxtm := 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 occtxc := 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 somethingfunc work(ctx context.Context, name string) {for {select {case <-ctx.Done():fmt.Printf("%s get msg to cancel\n", name)returndefault:fmt.Printf("%s is running \n", name)time.Sleep(1 * time.Second)}}}//do something and pass values by contextfunc workWithValue(ctx context.Context, name string) {for {select {case <-ctx.Done():fmt.Printf("%s get msg to cancel\n", name)returndefault: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,及时的退出并且释放资源

整个调用栈如下图