Context
在Go语言圈子中流行着一句话：
Never start a goroutine without knowing how it will stop。
翻译：如果你不知道协程如何退出，就不要使用它。
在创建协程时，我们可能还会再创建一些别的子协程，那么这些协程的退出就成了问题。在Go1.7之后，Go官方引入了Context来实现协程的退出。不仅如此，Context还提供了跨协程、甚至是跨服务的退出管理。
Context本身的含义是上下文，我们可以理解为它内部携带了超时信息、退出信号，以及其他一些上下文相关的值（例如携带本次请求中上下游的唯一标识trace_id）。由于Context携带了上下文信息，父子协程之间就可以”联动“ 了。
Context标准库
在Context标准库中重要的结构 context.Context其实是一个接口，它提供了Deadline、Done、Err、Value这4种方法：
type Context interface {
Deadline() (deadline time.Time, ok bool)
Done() <-chan struct{}
Err() error
Value(key interface{}) interface{}
}
Deadline方法用于返回Context的过期时间。Deadline第一个返回值表示Context的过期时间，第二个返回值表示是否设置了过期时间，如果多次调用Deadline方法会返回相同的值。
Done是使用最频繁的方法，它会返回一个通道。一般的做法是调用者在select中监听该通道的信号，如果该通道关闭则表示服务超时或异常，需要执行后续退出逻辑。多次调用Done方法会返回相同的通道。
通道关闭后，Err方法回返回退出的原因。
Value方法返回指定Key对应的value，这是Context携带的值。Key必须是可比较的，一般用法Key是一个全局变量，通过context.WithValue将key存储到Context中，并通过Context.Value方法退出。
Context是一个接口，这意味着需要有对应的具体实现。用户可以自己实现Context接口，并严格遵守Context接口。
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 interface{}) interface{} {
return nil
}
因此，要具体使用Context，需要派生出新的Context。我们使用的最多的还是Go标准库中的实现。
前三个函数都用于派生出有退出功能的Context。
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)
func WithValue(parent Context, key, val interface{}) Context
WithCancel函数回返回一个子Context和cancel方法。子Context会在两种情况下触发退出：一种情况是调用者主动调用了返回的cancel方法；另一种情况是当参数中的父Context退出时，子Context将级联退出。
WithTimeout函数指定超时时间。当超时发生后，子Context将退出。因此，子Context的退出有三种时机，一种是父Context退出；一种是超时退出；最后一种是主动调用cancel函数退出。
WithDeadline和WithTimeout函数的处理方法相似，不过它们的参数指定的是最后到期的时间。
WithValue函数会返回带key-value的子Context。
Context实践
eg：
下面的代码中childCtx是preCtx的子Context，其设置的超时时间为300ms。但是preCtx的超时时间为100ms，因此父Context退出后，子Context会立即退出，实际的等待时间只有100ms。
func main() {
ctx := context.Background()
before := time.Now()
preCtx, _ := context.WithTimeout(ctx, 100*time.Millisecond)
go func() {
childCtx, _ := context.WithTimeout(preCtx, 300*time.Millisecond)
select {
case <-childCtx.Done():
after := time.Now()
fmt.Println("child during:", after.Sub(before).Milliseconds())
}
}()
select {
case <-preCtx.Done():
after := time.Now()
fmt.Println("pre during:", after.Sub(before).Milliseconds())
}
}
这是输出如下，父Context与子Context退出的时间差接近100ms：
pre during: 104
child during: 104
当我们把preCtx的超时时间修改为500ms时：
preCtx ,_:= context.WithTimeout(ctx,500*time.Millisecond)
从新的输出中可以看出，子协程的退出不会影响父协程的退出。
child during: 304
pre during: 500
Context底层原理
Context在很大程度上利用了通道的一个特性：通道在close时，会通知所有监听它的协程。
每个派生出的子Context都会创建一个新的退出通道，这样，只要组织好Context之间的关系，就可以实现继承链上退出信号的传递。如图所示的三个协程中，关闭通道A会连带关闭调用链上的通道B，通道B会关闭通道C。
要使用context的退出功能，需要调用WithCancel或WithTimeout，派生出一个新的结构Context。WithCancel底层对应的结构为cancelCtx，WithTimeout底层对应的结构为timerCtx，timerCtx包装了cancelCtx，并存储了超时时间。
type cancelCtx struct {
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
}
type timerCtx struct {
cancelCtx
timer *time.Timer // Under cancelCtx.mu.
deadline time.Time
}
cancelCtx第一个字段保留了父Context的信息。children字段则保存了当前Context派生的子Context的信息，每个Context都会有一个单独的done通道。
而WithDeadline函数会先判断父Context设置的超时时间是否比当前Context的超时时间短，如果是，那么子协程会随着父Context的退出而退出，没有必要再设置定时器。
当我们使用了标准库中默认的Context实现时，propagateCancel函数将子Context加入父协程的children哈希表中，并开启一个定时器。当定时器到期时，会调用cancel方法关闭通道，级联关闭当前Context派生的子Context，并取消与父Context的绑定关系。这种特性就产生了调用链上连锁的退出反应。
