Incoming requests to a server should create a [Context], and outgoing calls to servers should accept a Context. The chain of function calls between them must propagate the Context, optionally replacing it with a derived Context created using [WithCancel], [WithDeadline], [WithTimeout], or [WithValue]. When a Context is canceled, all Contexts derived from it are also canceled.
// Background returns a non-nil, empty [Context]. It is never canceled, has no // values, and has no deadline. It is typically used by the main function, // initialization, and tests, and as the top-level Context for incoming // requests. // 首先是空的，其次应该用在应用程序的开头，作为parent context
// TODO returns a non-nil, empty [Context]. Code should use context.TODO when // it's unclear which Context to use or it is not yet available (because the // surrounding function has not yet been extended to accept a Context // parameter). // 首先是空的，其次应该用在你不知道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 cause error// set to non-nil by the first cancel call }
// propagateCancel arranges for child to be canceled when parent is. // It sets the parent context of cancelCtx. func(c *cancelCtx) propagateCancel(parent Context, child canceler) { c.Context = parent // 这是一些判断条件，判断 parent 的形式 done := parent.Done() if done == nil { return// parent is never canceled }
select { case <-done: // parent is already canceled child.cancel(false, parent.Err(), Cause(parent)) return default: } // 如果 patent 是 cancel ,则传播cancel if p, ok := parentCancelCtx(parent); ok { // parent is a *cancelCtx, or derives from one. p.mu.Lock() if p.err != nil { // parent has already been canceled child.cancel(false, p.err, p.cause) } else { if p.children == nil { p.children = make(map[canceler]struct{}) } p.children[child] = struct{}{} } p.mu.Unlock() return } // afterFuncer 这里本博客没讲，主要的作用就是当channel关闭后实现的函数 if a, ok := parent.(afterFuncer); ok { // parent implements an AfterFunc method. c.mu.Lock() stop := a.AfterFunc(func() { child.cancel(false, parent.Err(), Cause(parent)) }) c.Context = stopCtx{ Context: parent, stop: stop, } c.mu.Unlock() return }
goroutines.Add(1) gofunc() { select { case <-parent.Done(): child.cancel(false, parent.Err(), Cause(parent)) case <-child.Done(): } }() }
// cancel closes c.done, cancels each of c's children, and, if // removeFromParent is true, removes c from its parent's children. // cancel sets c.cause to cause if this is the first time c is canceled. func(c *cancelCtx) cancel(removeFromParent bool, err, cause error) { if err == nil { panic("context: internal error: missing cancel error") } if cause == nil { cause = err } c.mu.Lock() if c.err != nil { c.mu.Unlock() return// already canceled } c.err = err c.cause = cause // 这里是实现一个懒加载 d, _ := c.done.Load().(chanstruct{}) if d == nil { c.done.Store(closedchan) } else { close(d) } // 上面都不用看，主要是下面这个逐一cancel for child := range c.children { // NOTE: acquiring the child's lock while holding parent's lock. child.cancel(false, err, cause) } c.children = nil c.mu.Unlock()
if removeFromParent { removeChild(c.Context, c) } }
// parentCancelCtx returns the underlying *cancelCtx for parent. // It does this by looking up parent.Value(&cancelCtxKey) to find // the innermost enclosing *cancelCtx and then checking whether // parent.Done() matches that *cancelCtx. (If not, the *cancelCtx // has been wrapped in a custom implementation providing a // different done channel, in which case we should not bypass it.) funcparentCancelCtx(parent Context) (*cancelCtx, bool) { done := parent.Done() // 是不是已经关闭或者不可cancel if done == closedchan || done == nil { returnnil, false } // 判断是不是 cancelCtx p, ok := parent.Value(&cancelCtxKey).(*cancelCtx) if !ok { returnnil, false } // 懒加载 pdone, _ := p.done.Load().(chanstruct{}) if pdone != done { returnnil, false } return p, true }
移出某个子cancel上下文
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
// removeChild removes a context from its parent. funcremoveChild(parent Context, child canceler) { if s, ok := parent.(stopCtx); ok { s.stop() return } p, ok := parentCancelCtx(parent) if !ok { return } p.mu.Lock() if p.children != nil { delete(p.children, child) } p.mu.Unlock() }
// A canceler is a context type that can be canceled directly. The // implementations are *cancelCtx and *timerCtx. type canceler interface { cancel(removeFromParent bool, err, cause error) Done() <-chanstruct{} }
// A timerCtx carries a timer and a deadline. It embeds a cancelCtx to // implement Done and Err. It implements cancel by stopping its timer then // delegating to cancelCtx.cancel. type timerCtx struct { cancelCtx timer *time.Timer // Under cancelCtx.mu.
func value(c Context, key any) any { for { switch ctx := c.(type) { case *valueCtx: if key == ctx.key { return ctx.val } c = ctx.Context case *cancelCtx: if key == &cancelCtxKey { return c } c = ctx.Context case withoutCancelCtx: if key == &cancelCtxKey { // This implements Cause(ctx) == nil // when ctx is created using WithoutCancel. return nil } c = ctx.c case *timerCtx: if key == &cancelCtxKey { return &ctx.cancelCtx } c = ctx.Context case backgroundCtx, todoCtx: return nil default: return c.Value(key) } } }
