// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package context defines the Context type, which carries deadlines,
// cancellation signals, and other request-scoped values across API boundaries
// and between processes.
//
// 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.
//
// The WithCancel, WithDeadline, and WithTimeout functions take a
// Context (the parent) and return a derived Context (the child) and a
// CancelFunc. Calling the CancelFunc cancels the child and its
// children, removes the parent's reference to the child, and stops
// any associated timers. Failing to call the CancelFunc leaks the
// child and its children until the parent is canceled or the timer
// fires. The go vet tool checks that CancelFuncs are used on all
// control-flow paths.
//
// The WithCancelCause function returns a CancelCauseFunc, which
// takes an error and records it as the cancellation cause. Calling
// Cause on the canceled context or any of its children retrieves
// the cause. If no cause is specified, Cause(ctx) returns the same
// value as ctx.Err().
//
// Programs that use Contexts should follow these rules to keep interfaces
// consistent across packages and enable static analysis tools to check context
// propagation:
//
// Do not store Contexts inside a struct type; instead, pass a Context
// explicitly to each function that needs it. The Context should be the first
// parameter, typically named ctx:
//
// func DoSomething(ctx context.Context, arg Arg) error {
// // ... use ctx ...
// }
//
// Do not pass a nil Context, even if a function permits it. Pass context.TODO
// if you are unsure about which Context to use.
//
// Use context Values only for request-scoped data that transits processes and
// APIs, not for passing optional parameters to functions.
//
// The same Context may be passed to functions running in different goroutines;
// Contexts are safe for simultaneous use by multiple goroutines.
//
// See https://blog.golang.org/context for example code for a server that uses
// Contexts.
package context
import (
"errors"
"internal/reflectlite"
"sync"
"sync/atomic"
"time"
)
// A Context carries a deadline, a cancellation signal, and other values across
// API boundaries.
// Context跨越API边界携带最后期限、取消信号和其他值。
// Context's methods may be called by multiple goroutines simultaneously.
// 上下文的方法可以由多个goroutine同时调用。
type Context interface {
// Deadline returns the time when work done on behalf of this context
// should be canceled. Deadline returns ok==false when no deadline is
// set. Successive calls to Deadline return the same results.
// Deadline返回代表此上下文完成的工作应被取消的时间。当没有设置截止日期时,Deadline返回ok==false。对Deadline的连续调用返回相同的结果
Deadline() (deadline time.Time, ok bool)
// Done returns a channel that's closed when work done on behalf of this
// context should be canceled. Done may return nil if this context can
// never be canceled. Successive calls to Done return the same value.
// The close of the Done channel may happen asynchronously,
// after the cancel function returns.
// Done返回一个通道,该通道在代表此上下文完成的工作应该取消时关闭。如果此上下文永远无法取消,则Done可能返回nil。
// 对Done的连续调用返回相同的值。在取消函数返回后,完成通道的关闭可能会异步发生。
// WithCancel arranges for Done to be closed when cancel is called;
// WithDeadline arranges for Done to be closed when the deadline
// expires; WithTimeout arranges for Done to be closed when the timeout
// elapses.
// WithCancel在调用cancel时安排关闭Done;WithDeadline安排在截止日期到期时关闭Done;WithTimeout会安排在超时结束时关闭“完成”。
// Done is provided for use in select statements:
// 提供了Done以用于select语句:
// // Stream generates values with DoSomething and sends them to out
// // until DoSomething returns an error or ctx.Done is closed.
// 流使用DoSomething生成值并将其发送到out,直到DoSometing返回错误或ctx.Done关闭为止。
// func Stream(ctx context.Context, out chan<- Value) error {
// for {
// v, err := DoSomething(ctx)
// if err != nil {
// return err
// }
// select {
// case <-ctx.Done():
// return ctx.Err()
// case out <- v:
// }
// }
// }
//
// See https://blog.golang.org/pipelines for more examples of how to use
// a Done channel for cancellation.
// 看见https://blog.golang.org/pipelines有关如何使用“完成”频道进行取消的更多示例。
Done() <-chan struct{}
// If Done is not yet closed, Err returns nil.
// If Done is closed, Err returns a non-nil error explaining why:
// Canceled if the context was canceled
// or DeadlineExceeded if the context's deadline passed.
// After Err returns a non-nil error, successive calls to Err return the same error.
// 如果Done尚未关闭,Err将返回nil。如果Done已关闭,Err将返回一个非零错误,解释原因:如果上下文已取消,则返回Canceled;
// 如果上下文的截止日期已过,则返回DeadlineExceeded。在Err返回非零错误之后,对Err的连续调用将返回相同的错误。
Err() error
// Value returns the value associated with this context for key, or nil
// if no value is associated with key. Successive calls to Value with
// the same key returns the same result.
// Value为键返回与此上下文关联的值,如果没有值与键关联,则返回nil。使用相同的键连续调用Value将返回相同的结果。
// Use context values only for request-scoped data that transits
// processes and API boundaries, not for passing optional parameters to
// functions.
// 仅对传递进程和API边界的请求类数据使用上下文值,而不对函数传递可选参数使用上下文值。
// A key identifies a specific value in a Context. Functions that wish
// to store values in Context typically allocate a key in a global
// variable then use that key as the argument to context.WithValue and
// Context.Value. A key can be any type that supports equality;
// packages should define keys as an unexported type to avoid
// collisions.
// 键标识上下文中的特定值。希望在Context中存储值的函数通常在全局变量中分配一个键,然后将该键用作Context.WithValue和Context.Value的参数。
// 键可以是任何支持相等的类型;包应该将密钥定义为未导出的类型,以避免冲突。
// Packages that define a Context key should provide type-safe accessors
// for the values stored using that key:
// 定义上下文键的包应为使用该键存储的值提供类型安全的访问器:
// // Package user defines a User type that's stored in Contexts.
// package user
//
// import "context"
//
// // User is the type of value stored in the Contexts.
// type User struct {...}
//
// // key is an unexported type for keys defined in this package.
// // This prevents collisions with keys defined in other packages.
// type key int
//
// // userKey is the key for user.User values in Contexts. It is
// // unexported; clients use user.NewContext and user.FromContext
// // instead of using this key directly.
// var userKey key
//
// // NewContext returns a new Context that carries value u.
// func NewContext(ctx context.Context, u *User) context.Context {
// return context.WithValue(ctx, userKey, u)
// }
//
// // FromContext returns the User value stored in ctx, if any.
// func FromContext(ctx context.Context) (*User, bool) {
// u, ok := ctx.Value(userKey).(*User)
// return u, ok
// }
Value(key any) any
}
// Canceled is the error returned by Context.Err when the context is canceled.
// Canceled是Context返回的错误。取消上下文时出错。
var Canceled = errors.New("context canceled")
// DeadlineExceeded is the error returned by Context.Err when the context's
// deadline passes.
// DeadlineExceeded是上下文返回的错误。当上下文的截止日期过去时出错。
var DeadlineExceeded error = deadlineExceededError{}
type deadlineExceededError struct{}
func (deadlineExceededError) Error() string { return "context deadline exceeded" }
func (deadlineExceededError) Timeout() bool { return true }
func (deadlineExceededError) Temporary() bool { return true }
// An emptyCtx is never canceled, has no values, and has no deadline. It is not
// struct{}, since vars of this type must have distinct addresses.
// emptyTx从未被取消,没有值,也没有截止日期。它不是结构{},因为此类型的变量必须具有不同的地址。
type emptyCtx int
func (*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 any) any {
return nil
}
func (e *emptyCtx) String() string {
switch e {
case background:
return "context.Background"
case todo:
return "context.TODO"
}
return "unknown empty Context"
}
var (
background = new(emptyCtx)
todo = new(emptyCtx)
)
// 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.
// Background返回一个非零的空Context。它从未被取消,没有价值,也没有截止日期。它通常由主函数、初始化和测试使用,并作为传入请求的顶级上下文。
func Background() Context {
return background
}
// 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).
// TODO返回一个非零的空上下文。当不清楚要使用哪个context或它还不可用时(因为周围的函数还没有扩展为接受context参数),代码应该使用context.TDO。
func TODO() Context {
return todo
}
// A CancelFunc tells an operation to abandon its work.
// A CancelFunc does not wait for the work to stop.
// A CancelFunc may be called by multiple goroutines simultaneously.
// After the first call, subsequent calls to a CancelFunc do nothing.
// CancelFunc告诉一个操作放弃它的工作。CancelFunc不会等待工作停止。
// CancelFunc可以由多个goroutine同时调用。在第一次调用之后,对CancelFunc的后续调用将不执行任何操作。
type CancelFunc func()
// WithCancel returns a copy of parent with a new Done channel. The returned
// context's Done channel is closed when the returned cancel function is called
// or when the parent context's Done channel is closed, whichever happens first.
// WithCancel返回带有新“完成”通道的父级的副本。
// 调用返回的cancel函数或关闭父上下文的Done通道时(以先发生的为准),返回的上下文的Done通道将关闭。
// Canceling this context releases resources associated with it, so code should
// call cancel as soon as the operations running in this Context complete.
// 取消此上下文将释放与其关联的资源,因此代码应在该上下文中运行的操作完成后立即调用cancel。
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
c := withCancel(parent)
return c, func() { c.cancel(true, Canceled, nil) }
}
// A CancelCauseFunc behaves like a CancelFunc but additionally sets the cancellation cause.
// This cause can be retrieved by calling Cause on the canceled Context or on
// any of its derived Contexts.
//
// If the context has already been canceled, CancelCauseFunc does not set the cause.
// For example, if childContext is derived from parentContext:
// - if parentContext is canceled with cause1 before childContext is canceled with cause2,
// then Cause(parentContext) == Cause(childContext) == cause1
// - if childContext is canceled with cause2 before parentContext is canceled with cause1,
// then Cause(parentContext) == cause1 and Cause(childContext) == cause2
// CancelCauseFunc的行为与CancelFunc类似,但会额外设置取消原因。可以通过对取消的上下文或其任何派生上下文调用cause来检索此原因。
// 如果上下文已被取消,CancelCauseFunc不会设置原因。例如,如果childContext是从parentContext派生的:
// -如果在用cause2取消childContext之前用cause1取消了parentContext,则Cause(parentContent)==Cause(childContext)==cause1
//-如果在用cause1取消parentContext之前用cause2取消了childContext,则Cause(parentContent)==cause1和Cause(childContext)==rease2
type CancelCauseFunc func(cause error)
// WithCancelCause behaves like WithCancel but returns a CancelCauseFunc instead of a CancelFunc.
// Calling cancel with a non-nil error (the "cause") records that error in ctx;
// it can then be retrieved using Cause(ctx).
// Calling cancel with nil sets the cause to Canceled.
// WithCancelCause的行为与WithCancel类似,但返回CancelCauseFunc而不是CancelFunc。调用具有非零错误(“原因”)的cancel会在ctx中记录该错误;然后可以使用Cause(ctx)来检索它。使用nil调用cancel会将原因设置为Canceled
// Example use:
//
// ctx, cancel := context.WithCancelCause(parent)
// cancel(myError)
// ctx.Err() // returns context.Canceled
// context.Cause(ctx) // returns myError
func WithCancelCause(parent Context) (ctx Context, cancel CancelCauseFunc) {
c := withCancel(parent)
return c, func(cause error) { c.cancel(true, Canceled, cause) }
}
func withCancel(parent Context) *cancelCtx {
if parent == nil {
panic("cannot create context from nil parent")
}
c := newCancelCtx(parent)
propagateCancel(parent, c)
return c
}
// Cause returns a non-nil error explaining why c was canceled.
// The first cancellation of c or one of its parents sets the cause.
// If that cancellation happened via a call to CancelCauseFunc(err),
// then Cause returns err.
// Otherwise Cause(c) returns the same value as c.Err().
// Cause returns nil if c has not been canceled yet.
// Cause返回一个非零错误,解释c被取消的原因。c或其父母之一的第一次取消决定了原因。
// 如果取消是通过调用CancelCauseFunc(err)发生的,则Cause返回err。否则,Cause(c)返回与c.Err()相同的值。如果c尚未取消,Cause返回nil。
func Cause(c Context) error {
if cc, ok := c.Value(&cancelCtxKey).(*cancelCtx); ok {
cc.mu.Lock()
defer cc.mu.Unlock()
return cc.cause
}
return nil
}
// newCancelCtx returns an initialized cancelCtx. newCancelCtx返回一个初始化的cancelCtx。
func newCancelCtx(parent Context) *cancelCtx {
return &cancelCtx{Context: parent}
}
// goroutines counts the number of goroutines ever created; for testing. goroutines统计有史以来创建的goroutine的数量;用于测试。
var goroutines atomic.Int32
// propagateCancel arranges for child to be canceled when parent is.
// propagateCancel安排在父级为时取消子级。
func propagateCancel(parent Context, child canceler) {
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:
}
if p, ok := parentCancelCtx(parent); ok {
p.mu.Lock()
if p.err != nil {
//
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()
} else {
goroutines.Add(1)
go func() {
select {
case <-parent.Done():
child.cancel(false, parent.Err(), Cause(parent))
case <-child.Done():
}
}()
}
}
// &cancelCtxKey is the key that a cancelCtx returns itself for. &cancelCtxKey是cancelCxx返回自身的密钥。
var cancelCtxKey int
// 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.)
// parentCancelCtx返回parent的基础*cancelCtx。它通过查找parent.Value(&cancelCtxKey)来找到最内部的封闭*cancelCtx
// 然后检查parent.Done()是否与该*cancel Ctx匹配。(如果不是,*cancelCtx已经封装在一个自定义实现中,提供了一个不同的done通道,
// 在这种情况下,我们不应该绕过它。)
func parentCancelCtx(parent Context) (*cancelCtx, bool) {
done := parent.Done()
if done == closedchan || done == nil {
return nil, false
}
p, ok := parent.Value(&cancelCtxKey).(*cancelCtx)
if !ok {
return nil, false
}
pdone, _ := p.done.Load().(chan struct{})
if pdone != done {
return nil, false
}
return p, true
}
// removeChild removes a context from its parent.
// removeChild从其父对象中删除上下文。
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()
}
// A canceler is a context type that can be canceled directly. The
// implementations are *cancelCtx and *timerCtx.
// canceler是一种可以直接取消的上下文类型。实现是*cancelCtx和*timerCtx。
type canceler interface {
cancel(removeFromParent bool, err, cause error)
Done() <-chan struct{}
}
// closedchan is a reusable closed channel.
// closedchan是一个可重复使用的关闭的通道。
var closedchan = make(chan struct{})
func init() {
close(closedchan)
}
// A cancelCtx can be canceled. When canceled, it also cancels any children
// that implement canceler.
// cancelCtx可以被取消。取消时,它还会取消任何实现取消器的子项。
type cancelCtx struct {
Context
mu sync.Mutex // protects following fields
done atomic.Value // of chan struct{}, created lazily, closed by first cancel call
// 保护chan结构{}的以下字段,这些字段是延迟创建的,由第一个取消调用关闭
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
}
func (c *cancelCtx) Value(key any) any {
if key == &cancelCtxKey {
return c
}
return value(c.Context, key)
}
func (c *cancelCtx) Done() <-chan struct{} {
d := c.done.Load()
if d != nil {
return d.(chan struct{})
}
c.mu.Lock()
defer c.mu.Unlock()
d = c.done.Load()
if d == nil {
d = make(chan struct{})
c.done.Store(d)
}
return d.(chan struct{})
}
func (c *cancelCtx) Err() error {
c.mu.Lock()
err := c.err
c.mu.Unlock()
return err
}
type stringer interface {
String() string
}
func contextName(c Context) string {
if s, ok := c.(stringer); ok {
return s.String()
}
return reflectlite.TypeOf(c).String()
}
func (c *cancelCtx) String() string {
return contextName(c.Context) + ".WithCancel"
}
// 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.
// cancel关闭c.done,取消c的每个子项,如果removeFromParent为true,则从其父项中删除c。cancel将c.cause设置为cause(如果这是第一次取消c)。
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().(chan struct{})
if d == nil {
c.done.Store(closedchan)
} else {
close(d)
}
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)
}
}
// WithDeadline returns a copy of the parent context with the deadline adjusted
// to be no later than d. If the parent's deadline is already earlier than d,
// WithDeadline(parent, d) is semantically equivalent to parent. The returned
// context's Done channel is closed when the deadline expires, when the returned
// cancel function is called, or when the parent context's Done channel is
// closed, whichever happens first.
//
// Canceling this context releases resources associated with it, so code should
// call cancel as soon as the operations running in this Context complete.
// WithDeadline返回父上下文的副本,其截止日期调整为不晚于d。如果父上下文的截止日期已经早于d,则WithDeadlline(parent,d)在语义上等同于父上下文。
// 当截止日期到期时,当调用返回的cancel函数时,或者当父上下文的Done通道关闭时(以先发生的为准),返回的上下文的Done通道将关闭。
// 取消此上下文将释放与其关联的资源,因此代码应在该上下文中运行的操作完成后立即调用cancel。
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
if parent == nil {
panic("cannot create context from nil parent")
}
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, nil) // deadline has already passed
return c, func() { c.cancel(false, Canceled, nil) }
}
c.mu.Lock()
defer c.mu.Unlock()
if c.err == nil {
c.timer = time.AfterFunc(dur, func() {
c.cancel(true, DeadlineExceeded, nil)
})
}
return c, func() { c.cancel(true, Canceled, nil) }
}
// 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.
// timerCtx包含一个定时器和一个截止日期。它嵌入了一个cancelCtx来实现Done和Err。它通过停止计时器然后委派给cancelCtx.cancel来实现取消。
type timerCtx struct {
*cancelCtx
timer *time.Timer // Under cancelCtx.mu.
deadline time.Time
}
func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
return c.deadline, true
}
func (c *timerCtx) String() string {
return contextName(c.cancelCtx.Context) + ".WithDeadline(" +
c.deadline.String() + " [" +
time.Until(c.deadline).String() + "])"
}
func (c *timerCtx) cancel(removeFromParent bool, err, cause error) {
c.cancelCtx.cancel(false, err, cause)
if removeFromParent {
// Remove this timerCtx from its parent cancelCtx's children. 从其父cancelCtx的子项中删除此timerCtx。
removeChild(c.cancelCtx.Context, c)
}
c.mu.Lock()
if c.timer != nil {
c.timer.Stop()
c.timer = nil
}
c.mu.Unlock()
}
// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
// WithTimeout返回WithDeadline(父级,time.Now().Add(超时))。
// Canceling this context releases resources associated with it, so code should
// call cancel as soon as the operations running in this Context complete:
// 取消此上下文将释放与其关联的资源,因此代码应在该上下文中运行的操作完成后立即调用cancel:
// func slowOperationWithTimeout(ctx context.Context) (Result, error) {
// ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
// defer cancel() // releases resources if slowOperation completes before timeout elapses
// return slowOperation(ctx)
// }
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
return WithDeadline(parent, time.Now().Add(timeout))
}
// WithValue returns a copy of parent in which the value associated with key is
// val.
// WithValue返回父项的副本,其中与键关联的值为val。
// Use context Values only for request-scoped data that transits processes and
// APIs, not for passing optional parameters to functions.
// 仅将上下文值用于传输进程和API的请求范围的数据,而不用于将可选参数传递给函数。
// The provided key must be comparable and should not be of type
// string or any other built-in type to avoid collisions between
// packages using context. Users of WithValue should define their own
// types for keys. To avoid allocating when assigning to an
// interface{}, context keys often have concrete type
// struct{}. Alternatively, exported context key variables' static
// type should be a pointer or interface.
// 提供的键必须是可比较的,并且不应是字符串或任何其他内置类型,以避免使用上下文的包之间发生冲突。
// WithValue的用户应该定义自己的密钥类型。为了避免在分配给接口{}时进行分配,上下文键通常具有具体的类型结构{}。
// 或者,导出的上下文键变量的静态类型应该是指针或接口。
func WithValue(parent Context, key, val any) 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}
}
// A valueCtx carries a key-value pair. It implements Value for that key and
// delegates all other calls to the embedded Context.
// valueCtx携带一个键值对。它实现该键的Value,并将所有其他调用委托给嵌入式上下文。
type valueCtx struct {
Context
key, val any
}
// stringify tries a bit to stringify v, without using fmt, since we don't
// want context depending on the unicode tables. This is only used by
// *valueCtx.String().
// stringify尝试在不使用fmt的情况下使用stringify v,因为我们不希望上下文依赖于unicode表。这仅由*valueCtx.String()使用。
func stringify(v any) string {
switch s := v.(type) {
case stringer:
return s.String()
case string:
return s
}
return "<not Stringer>"
}
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 any) any {
if c.key == key {
return c.val
}
return value(c.Context, key)
}
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 *timerCtx:
if key == &cancelCtxKey {
return ctx.cancelCtx
}
c = ctx.Context
case *emptyCtx:
return nil
default:
return c.Value(key)
}
}
}
【Golang1.20源码阅读】context/context.go
原创
©著作权归作者所有:来自51CTO博客作者深漂小码哥的原创作品,请联系作者获取转载授权,否则将追究法律责任
提问和评论都可以,用心的回复会被更多人看到
评论
发布评论
相关文章
-
Apache Doris 聚合函数源码阅读与解析|源码解读系列
Apache Doris Active Contributor 隐形通过本文记录下对源码的理解,以方便新人快速上手源码开发。
Apache Doris 数据库 大数据 数据分析 数据仓库 -
【Golang1.20源码阅读】math/const.go
golang 数学常量极限值
golang Powered by 金山文档 ide Max 浮点型 -
【Golang1.20源码阅读】builtin/builtin.go
【Golang源码阅读】builtin/builtin.go
golang Powered by 金山文档 Go 字符串 ci -
【Golang1.20源码阅读】bytes/buffer.go
【代码】【Golang1.20源码阅读】bytes/buffer.go。
golang ci 字节数 字符串 -
【Golang1.20源码阅读】runtime/string.go
【代码】【Golang1.20源码阅读】runtime/string.go。
golang 字符串 sed 编译器 -
【Golang1.20源码阅读】strings/compare.go
【代码】【Golang1.20源码阅读】strings/compare.go。
golang 字符串 Go 比较运算符 -
【Golang1.20源码阅读】sync/rwmutex.go
【代码】【Golang1.20源码阅读】sync/rwmutex.go。
golang 信号量 Go sed -
【Golang1.20源码阅读】runtime/chan.go
【代码】【Golang1.20源码阅读】chan.go。
golang sed 堆栈 Go -
【Golang1.20源码阅读】sync/waitgroup.go
【代码】【Golang1.20源码阅读】sync/waitgroup.go。
golang Group sed Go -
【Golang1.20源码阅读】sync/mutex.go
【代码】【Golang1.20源码阅读】sync/mutex.go。
golang 开发语言 互斥 互斥对象 ide -
【Golang1.20源码阅读】runtime/map.go
【代码】【Golang1.20源码阅读】runtime/map.go。
golang 开发语言 后端 Go 数组 -
【Golang1.20源码阅读】runtime/select.go
【代码】【Golang1.20源码阅读】runtime/select.go。
golang 开发语言 后端 堆栈 数组 -
【Golang1.20源码阅读】runtime/slice.go
【代码】【Golang1.20源码阅读】slice.go。
golang 开发语言 初始化 ci -
【Gin-v1.9.0源码阅读】context.go
【代码】【Gin-v1.9.0源码阅读】context.go。
golang 开发语言 gin 后端 JSON -
【Golang1.20源码阅读】crypto/sha256.go
【代码】【Golang1.20源码阅读】crypto/sha256.go。
golang 校验和 数据 ide -
Golang Context源码解析
Golang Context包源码解读
golang 初始化 sed 父节点