context 很重要，总体作用就是 设置程序执行的
- deadline 设置程序的截止日期
- status sync 同步信号
- submit value 设置共享变量
当上层 goroutine 需要通知 他下级 goroutine 及时终止程序，释放资源的时候，常用 context
简单来说，这三个功能貌似都可以使用 channel 实现，比如所有 gorountine 实现关闭，只要判断 channel close 了，就把所有函数 return ,释放资源。传递值也可以 通过 channel, 但是 记住 channel 的东西拿到一次就清除了。而context value 却可以多次取值。还有很多区别，下面就详细说一下 context 都有那些用处。
参考 [go 设计和实现 上下文 ](Context https://draveness.me/golang/docs/part3-runtime/ch06-concurrency/golang-context/)
context.Context 里面有什么东西
type Context interface {
Deadline() (deadline time.Time, ok bool) // 设置截至日期
Done() <-chan struct{} // 当前上下文 被取消时候，关闭，
Err() error // 上下文结束的时候，返回 Canceled / DeadlineExceeded 错误
Value(key interface{}) interface{} // 获取键值对
}
他就是一个接口，很简单吧，这个接口只是定义了最基本的 context 的东西，很多context 都是实现了这个接口，然后扩展了很多功能。
context.Context 里面的几个函数
context.emptyCtx
这个可以看出 她是 context 包的私有属性， 他只是为了 提供一个 实现了 context.Context 接口的 空 上下文，因为它实现的函数，没有具体的功能，只是为了给别人继承用的
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 interface{}) interface{} {
return nil
}
context.Background , context.TODO
var (
background = new(emptyCtx)
todo = new(emptyCtx)
)
func Background() Context {
return background
}
func TODO() Context {
return todo
}
其实 Background 和 TODO 实质试一样的，只是 变量名有种表面的含义
Background 代表 默认上下文， 而 TODO 代表 可能还不确定，怎么用。只是给开发人员看起来知道大概 context 大概用来干嘛的
（ps context 是可以被嵌套的，一级一级 包装， 添加更多的功能，就像继承一样）
创建一个可以被取消的 context
context.WithCancel
ctx := context.Background()
ctx, cancel := context.WithCancel(ctx)
// 在 其他 函数使用 ctx
cancel( ) // 关闭所有 goroutine 相关
// 所有使用 ctx 的 goroutine ctx.Done() 会有值， 那就表示要结束了，我们可以用 for select 结构 <- ctx.Done() 这样判断是不是需要结束这个 gorountine。
for {
select {
case <- ctx.Done():
child.cancel(false, parent.Err()) // 父上下文已经被取消
return
default:
// todo
}
创建一个可以被 定时 关闭的 context
context.WithDeadline // 第二个参数是时间对象
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)
context.WithTimeout // 第二个参数是时间间隔
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
return WithDeadline(parent, time.Now().Add(timeout))
}
ctx, cancel := context.WithDeadline( context.Background(), time.Now().Add(3 * time.Second) )
// 三秒之后自动调用 cancel 函数， 当然你也可以手动提前执行 cancel
// 其实 WithDeadline 内部是 调用 time.AfterFunc 延迟调用的 cancel
创建一个 可以传值的 context
context.WithValue 部分代码
type valueCtx struct {
Context
key, val interface{}
}
func WithValue(parent Context, key, val interface{}) Context {
if key == nil {
panic("nil key")
}
if !reflectlite.TypeOf(key).Comparable() {
panic("key is not comparable")
}
return &valueCtx{parent, key, val}
}
func (c *valueCtx) Value(key interface{}) interface{} {
if c.key == key {
return c.val
}
return c.Context.Value(key)
}
继承一个父 context 和一个 key value 值，就是简单的 设置 key value 的值， 取值 用 ctx.Value(key) 当前 context 没有 key 就去 上层 去找。
