c++实现polyline方法_Golang之contex底层实现及源码阅读

应用场景

主要在goroutine之间传递上下文信息，包括：退出信号、超时与截止时间、k-v键值对等。

context的产生

goroutine本身并没有parent/children关系，当遇到复杂的并发结构时，处理下游goroutine的退出将会变得艰难。

比如一个网络请求Request，每一个请求都需要开启一个或者多个goroutine处理一些业务，这些goroutine处理的过程中又衍生了更多的goroutine，goroutine的关系链把场景变的非常复杂。

在Go1.7版本开始提供了context标准库来解决类似问题。

context底层实现

整体类图

interface

context接口

作为一个基本接口，所有的context对象都要实现该接口。内部定义了4个方法(都是幂等)。

type Context interface {   // 返回取消该上下文完成的工作的时间。   // 如果未设置截止日期，则截止日期返回ok == false。   // 连续调用Deadline会返回相同的结果。   Deadline() (deadline time.Time, ok bool)   // 在context被取消或者到了deadline，返回一个被关闭的channel。   // 在源码中，因为没有任何地方向这个channel里面写入值，而且这是一个只读   // 的channel，因此，在goroutine中监听这个channel的时候，只有被关   // 闭的时候，才会读取到相应类型的零值，后续子goroutine便可以做退出操作。   //  func Stream(ctx context.Context, out chan   //     for {   //        v, err := DoSomething(ctx)   //        if err != nil {   //           return err   //        }   //        select {   //        case    //           return ctx.Err()   //        case out    //        }   //     }   //  }   Done() struct{}   // 如果尚未关闭Done，则Err返回nil。   // 如果关闭了Done，Err将返回一个被关闭的原因：   // 1、如果context已取消，返回context canceled；   // 2、如果context的截止日期已过，返回context deadline exceeded。   Err() error   // 获取key对应的value   Value(key interface{}) interface{}}

canceler接口

为拓展接口。实现了此接口的context，说明该context是可取消的。

// A canceler is a context type that can be canceled directly. The// implementations are *cancelCtx and *timerCtx.type canceler interface {   cancel(removeFromParent bool, err error)   Done() chan }

struct

emptyCtx

emptyCtx实现了一个不具备任何功能的context接口，也就是一个空的contex。emptyCtx永远不会被cancel，它没有值，也没有 deadline。

它不是struct {}，因为此类型的var必须具有不同的地址。它主要是作为context对象树的root节点。

type emptyCtx intfunc (*emptyCtx) Deadline() (deadline time.Time, ok bool) {   return}func (*emptyCtx) Done() chan struct{} {   return nil}func (*emptyCtx) Err() error {   return nil}func (*emptyCtx) Value(key interface{}) interface{} {   return nil}// todo和background两者本质上只有名字区别，在按string输出的时候会有区别。// emptyCtx的String方法可以返回当前context的具体类型，比如是Background还是TODO。// background和todo是两个全局变量，这里通过取其地址来进行对应类型的判断。func (e *emptyCtx) String() string {   switch e {   case background:      return "context.Background"   case todo:      return "context.TODO"   }   return "unknown empty Context"}

emptyCtx它被包装成全局变量，分别通过context.Background()和context.TODO()两个函数对用户公开。

var (   background = new(emptyCtx)   todo       = new(emptyCtx))// Background返回一个非空的Context。// 它通常由main函数，初始化和测试使用，并作为所有context的根节点。func Background() Context {   return background}// TODO返回一个非空的Context。TODO通常用在并不知道传递什么context的情形，代码应使用context.TODO。// 在很多的函数调用的过程中都会传递但是通常又不会使用，比如既不会监听退出，也不会从其中获取数据。// TODO跟Background一样，也是返回一个全局变量。func TODO() Context {   return todo}

Background

cancelCtx

cancelCtx结构体内嵌了一个Context对象，即其parent context，这样，它就可以被看成一个Context。

同时内部还通过children来保存所有可以被取消的context的接口，后续如果当前context被取消的时候，只需要调用所有canceler接口的context就可以实现当前调用链的取消。

type cancelCtx struct {   Context   mu       sync.Mutex            // protects following fields   done     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}

如果当前的goroutine持有的Context实例是可被Cancel的，那么它的所有child goroutine也应当是可被Cancel的，这也是cancelCtx类中存在Context字段和children字段的原因。

cancelCtx结构体字段解释：Context为父context；done字段是Done()方法的返回值；children中的key记录着所有的孩子，value是没有意义的；err字段是Err()方法的返回值。

Done方法的实现

func (c *cancelCtx) Done() struct{} {   c.mu.Lock()   // 内部变量 done “懒加载”，只有调用了 Done() 方法的时候才会被创建。   if c.done == nil {      c.done = make(chan struct{})   }   d := c.done   c.mu.Unlock()   return d}

Done操作返回当前的一个chan，用于通知goroutine退出。

cancel() 方法的实现

// 参数removeFromParent：是否需要把它从父节点的孩子中除名。// 将参数err赋值给字段err, 在方法Context.Err中返回。func (c *cancelCtx) cancel(removeFromParent bool, err error) {   if err == nil {      panic("context: internal error: missing cancel error")   }   // context一旦被某个操作操作触发取消后，就不会再进行任何状态的修改。   c.mu.Lock()   if c.err != nil {      c.mu.Unlock()      return // already canceled   }   c.err = err   // 关闭channel，通知其他协程。   if c.done == nil {      c.done = closedchan   } else {      close(c.done)   }   // 递归调用所有children取消。   for child := range c.children {       // 当c调用返回的cancelFunc时，执行cancel方法，会将c从它的父节点里移除(见[2])。       // 而c所有的children都会因为c.children = nil移除(见[1])，无需一个个处理。      child.cancel(false, err)   }   // [1]   c.children = nil   c.mu.Unlock()      // 如果为true，从父节点中移除自己[2]。   if removeFromParent {      removeChild(c.Context, c)   }}// 全局复用的, 被关闭的channel。var closedchan = make(chan struct{})func init() {   close(closedchan)}// parentCancelCtx判断Context实例是否是一个可被Cancel的类型。// parentCancelCtx只识别context标准包内的三种类型。// 如果用户自己的类实现了context.Context接口，或者把ctx包在了自己的类型内，或者是emptyCtx，将执行default。func parentCancelCtx(parent Context) (*cancelCtx, bool) {   for {      switch c := parent.(type) {      case *cancelCtx:         return c, true      case *timerCtx:         return &c.cancelCtx, true      case *valueCtx:         parent = c.Context      default:         return nil, false      }   }}// removeChild removes a context from its parent.func removeChild(parent Context, child canceler) {   p, ok := parentCancelCtx(parent)   if !ok {      return   }   p.mu.Lock()   if p.children != nil {      delete(p.children, child)   }   p.mu.Unlock()}

cancel关闭c.done，取消c的每个children，如果removeFromParent为true，则从其父级的子级中删除c。

WithCancel方法

它可以创建一个可取消的context。

// 多个goroutine可以同时调用CancelFunc，在第一个调用之后，随后对CancelFunc的调用什么都不做。// 调用该函数意味着将关闭Context, 结束相关的work。type CancelFunc func()// 从parent上派生出一个新的Context，并返回一个CancelFunc类型的函数。// 当调用对应的cancel函数时，该Context对应的Done()返回的只读channel也会被关闭。// 取消Context将释放与其关联的资源，因此在此context中某项任务的操作完成后，代码应立即调用返回的cancel函数。func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {   c := newCancelCtx(parent)   propagateCancel(parent, &c)   return &c, func() { c.cancel(true, Canceled) }} // 下面是WithCancel两个内部方法的实现。func newCancelCtx(parent Context) cancelCtx {   return cancelCtx{Context: parent}}func propagateCancel(parent Context, child canceler) {   // 说明父节点是emptyCtx，或者用户自己实现的context.Context。   if parent.Done() == nil {      return // parent is never canceled   }   // 如果父Context本身是可Cancel的。   if p, ok := parentCancelCtx(parent); ok {      // 说明父Context是以下三种之一:      // 1. 是一个cancelCtx, 本身就可被Cancel；      // 2. 是一个timerCtx, timerCtx是canctx的一个子类, 也可被Cancel；      // 3. 是一个valueCtx, valueCtx继承体系上的某个爹, 是以上两者之一。      p.mu.Lock()      if p.err != nil {         // parent has already been canceled         // 父节点已经被取消了，本节点(子节点)也要取消。         child.cancel(false, p.err)      } else {         // 若父节点未取消, 就把子节点添加到它的children列表中去。         if p.children == nil {            p.children = make(map[canceler]struct{})         }         p.children[child] = struct{}{}      }      p.mu.Unlock()   } else {      // 说明父Context虽然可被Cancel，但并不是标准库中预设的cancelCtx或timerCtx两种可被Cancel的类型。      // 这意味着这个特殊的父Context, 内部并不能保证记录了所有儿子的列表。      // 新开一个goroutine, 时刻监视着父Context的生存状态。      go func() {         select {         // 当父Context取消, 就立即调用child.cancel处理子节点。         case Done():            child.cancel(false, parent.Err())         // 如果子节点自己取消了，那就退出这个select，父节点的取消信号就不用管了。         // 如果去掉这个case，那么很可能父节点一直不取消，这个goroutine就泄漏了。         // 如果父节点取消了，子节点就会重复取消。         case Done():         }      }()   }}

调用cancel方法的时候，第一个参数是true，在取消的时候需要将自己从父节点里删除。第二个参数Canceled是一个固定的取消错误类型。

// Canceled is the error returned by Context.Err when the context is canceled.var Canceled = errors.New("context canceled")

timerCtx

带有超时的contex。

timerCtx继承了cancelCtx接口，同时还包含一个timer.Timer定时器(由标准库的time.Timer实现)和一个deadline终止实现。Timer会在deadline到来时，自动取消context。

type timerCtx struct {   cancelCtx   timer *time.Timer // Under cancelCtx.mu.   deadline time.Time}

Deadline()方法

它只是简单的字段deadline的getter。

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

cancel()取消方法

它重写了canceler.cancel方法。

cancel()方法首先进行cancelCtx的取消流程，然后进行自身的定时器的Stop操作。

func (c *timerCtx) cancel(removeFromParent bool, err error) {   c.cancelCtx.cancel(false, err)   if removeFromParent {      // Remove this timerCtx from its parent cancelCtx's children.      removeChild(c.cancelCtx.Context, c)   }   c.mu.Lock()   if c.timer != nil {      c.timer.Stop()      c.timer = nil   }   c.mu.Unlock()}

WithDeadline()方法

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {   if cur, ok := parent.Deadline(); ok && cur.Before(d) {      // 如果父节点也是一个有dealine的Context，而且dealine更靠前，以父节点的为准。      // 一旦父节点超时，子节点也会随之取消。      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 {      // d时间后，timer会自动调用cancel函数，当前的goroutine不会被阻塞。      c.timer = time.AfterFunc(dur, func() {         c.cancel(true, DeadlineExceeded)      })   }   return c, func() { c.cancel(true, Canceled) }}

可以看到，timerCtx只是对cancelCtx在功能上的追加WithDeadline也只是简单的追加了一个定时器。

如果要创建的这个子节点的deadline比父节点要晚，子节点在deadline 到来之前就已经被父节点取消了。

timer调用cancel函数传入的参数如下。

var DeadlineExceeded error = deadlineExceededError{}type deadlineExceededError struct{}func (deadlineExceededError) Error() string   { return "context deadline exceeded" }

另外，标准包还提供了一个WithTimeout函数，其实与WithDeadline是等价的。

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {   return WithDeadline(parent, time.Now().Add(timeout))}

WithTimeout函数调用了WithDeadline，传入的deadline是当前时间加上timeout的时间，需要用的是绝对时间。

valueCtx

带数据共享的非公开类valueCtx。其内部通过一个key/value进行值的存储，并且只能存储一个key(可比较的key)。

如果当前context不包含值则进行层层向上递归(父节点没法获取子节点存储的值，子节点却可以获取父节点的值)。

type valueCtx struct {   Context   key, val interface{}}func WithValue(parent Context, key, val interface{}) Context {   if key == nil {      panic("nil key")   }   if !reflectlite.TypeOf(key).Comparable() {      panic("key is not comparable")   }   return &valueCtx{parent, key, val}}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]  深度解密Go语言之context：

https://qcrao.com/2019/06/12/dive-into-go-context

[2]  Go context：

https://github.com/cch123/golang-notes/blob/master/context.md

[3]  图解Go语言的context了解编程语言核心实现源码：

https://www.cnblogs.com/buyicoding/p/12155169.html

[4]  golang中的context包：

https://www.cnblogs.com/neooelric/p/10668820.html