go context

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 就去上层去找。

go context

context 很重要，总体作用就是 设置程序执行的