在go服務器中，對于每個請求的request都是在單獨的goruitne中進行的，處理一個request可以設(shè)計多個gorouitne之間進行交互，
使用context可以使開發(fā)者方便這些gorouitne里傳遞相關(guān)的數(shù)據(jù)、取消gorouitne的signal或截止日期等

1、Context結(jié)構(gòu)
// 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相關(guān)函數(shù)停止當前的工作狀態(tài)

當一個父operation啟動一個gorouite用于子operation，這些子operation不能夠取消父operation，WithCanncel函數(shù)提供一種方式可以取消創(chuàng)建context

context可以安全的被多個gorouite使用，開發(fā)者可以把Context傳遞給任意多個gorouite然后cancel這個context的時候就能夠通知到所有的gorouite

Err 方法返回context為什么取消

Deadline 返回context何時會超時

Value 返回context相關(guān)的數(shù)據(jù)

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被關(guān)閉時關(guān)閉自己的Done通道或者在自己Cancel的時候關(guān)閉自己Done
WithCancel同時還返回一個取消cancel，這個cancel用于取消當前的Context