2021-08-24发表2024-08-23更新编程语言6 分钟读完 (大约931个字)

上下文golang context 实现原理

context 是 golang 中的经典工具，主要在异步场景中用于实现并发协调以及对 goroutine 的生命周期控制. 除此之外，context 还兼有一定的数据存储能力。本着知其然知其所以然的精神，本文和大家一起深入 context 源码一探究竟，较为细节地对其实现原理进行梳理.

核心数据结构

// context.Context
type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key any) any
}

Context 为 interface，定义了四个核心 api：

Deadline：返回 context 的过期时间；
Done：返回回用以标识 context 中是否结束的 channel；
Err：返回 ct× 错误；
Value：返回 context 中存放的对应 key 的值value.

// A Context carries a deadline, a cancellation signal, and other values across
// API boundaries.
//
// Context's methods may be called by multiple goroutines simultaneously.
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 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.
  //
  // 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.
  //
  // Done is provided for use in select statements:
  //
  //  // Stream generates values with DoSomething and sends them to out
  //  // until DoSomething returns an error or ctx.Done is closed.
  //  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.
  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.
  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.
  //
  // Use context values only for request-scoped data that transits
  // processes and API boundaries, not for passing optional parameters to
  // functions.
  //
  // 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.
  //
  // 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
}

标准 error

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

// DeadlineExceeded is the error returned by [Context.Err] when the context's
// deadline passes.
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 }