context包Context结构

在go服务器中，对于每个请求的request都是在单独的goruitne中进行的，处理一个request可以设计多个gorouitne之间进行交互，
使用context可以使开发者方便这些gorouitne里传递相关的数据、取消gorouitne的signal或截止日期等

1、Context结构
// A Context carries a deadline, a cancelation 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.
//
// 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 cancelation.
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 = 0
//
//  // 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 interface{}) interface{}

}

Done 方法在Context被取消或者是超时时候返回一个close的channel，close的channle可以作为广播通知，告诉给context相关函数停止当前的工作状态

当一个父operation启动一个gorouite用于子operation，这些子operation不能够取消父operation，WithCanncel函数提供一种方式可以取消创建context

context可以安全的被多个gorouite使用，开发者可以把Context传递给任意多个gorouite然后cancel这个context的时候就能够通知到所有的gorouite

Err 方法返回context为什么取消

Deadline 返回context何时会超时

Value 返回context相关的数据

2、继承Context
（1）Background
// 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.
func Background() Context {
return background
}
Background是所有Context的root不能够被cancel

（2）WithCancel
// 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.
//
// Canceling this context releases resources associated with it, so code should
// call cancel as soon as the operations running in this Context complete.
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
c := newCancelCtx(parent)
propagateCancel(parent, &c)
return &c, func() { c.cancel(true, Canceled) }
}

WithCancel返回一个继承的Context在父Context的Done被关闭时关闭自己的Done通道或者在自己Cancel的时候关闭自己Done
WithCancel同时还返回一个取消cancel，这个cancel用于取消当前的Context