定义

一个网络请求Request， 每个Request都需要开启一个goroutine做一些事情，这些goroutine又可能开启其它的goroutine。所以我们需要一种可以跟踪goroutine的方案，才可以达到控制他们的目的，这就是Go语言为我们提供的Context，称之为上下文非常贴切，它就是goroutine的上下文。

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go func(ctx context.Context) {
        for {
            select {
            case <- ctx.Done():
                fmt.Println("监控退出，停止了。。。")
            default:
                fmt.Println("goroutine监控中")
                time.Sleep(2 * time.Second)
            }
        }
    }(ctx)

    time.Sleep(10 * time.Second)
    fmt.Println("可以了，通知监控停止")
    cancel()
}

context.Background() 返回一个空的Context，这个空的Context一般用于整个Context树的根节点。然后我们可以使用context.WithCancel(parent)函数，创造一个可取消的子Context，然后当作参数传给goroutine使用，这样就可以使用这个子Context跟踪这个goroutine。

在gouroutine中，使用select调用<-ctx.Done()判断是否要结束，如果接受到值的话，就可以返回结束goroutine了，如果接收不到，就会继续进行监控。

那么是如何发送结束指令的呢，这就是示例中的cancel函数，它是我们调用context.WithCancel(parent)函数生成子Context的时候返回的，第二个返回值就是这个取消函数，它是CancelFunc类型的。我们调用它就可以发出取消指令，然后我们的监控goroutine就会收到信号，就会返回结束。

控制多个goroutine

使用Context控制一个goroutine的例子如上，非常简单，下面我们看看控制多个goroutine的例子。

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    go watch(ctx, "1")
    go watch(ctx, "2")

    cancel()
}

func watch(ctx context.Context, name string) {
    for {
        select {
        case <- ctx.Done():
            fmt.Println("完成")
            return
        default:
            fmt.Println("12")
        }
    }
}

示例启动了2个监控goroutine进行不断的监控，每一个都使用了Context进行跟踪，当我们使用cancel函数通知取消时，这2个goroutine都会被结束，这就是Context的控制能力，它就像一个控制器一样，按下开关后，所有基于这个Context或者衍生的子Context都会收到通知，这时就可以进行清理操作了，最终释放goroutine，这就优雅的解决了goroutine启动后不可控的问题。

Context接口

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    
    Done() <- chan struct{}
    
    Err() error
    
    Value(key interface{}) interface{}
}

Deadline方法是获取设置的截止时间的意思，第一个返回截止时间，到了这个时间点，Context会自动发起取消请求；第二个返回ok 等于false时，表示没有设置截止时间，如果需要取消的话，需要调用取消函数进行取消。

Done 方法返回一个只读的chan，类型为struct{},我们在goroutine中，如果该方法返回的chan可以读取，则意味着parent context已经发起了取消请求，我们通过Done方法收到这个信号后，就应该做清理操作，然后退出goroutine， 释放资源。

Err方法返回取消的错误原因，因为什么Context被取消。

Value方法获取该Context上绑定的值，是一个键值对，所以要通过一个Key才可以获取对应的值，这个值一般是线程安全的。

以上4个方法常用的就是Done了，如果Context取消的时候，我们就可以得到一个关闭的chan，关闭的chan是可以读取的，所以只要可以读取的时候，就意味着收到Context取消的信号了，以下是这个方法的经典用法。

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
        }
    }
}

Context接口并不需要我们实现，Go内置已经帮我们实现了2个，我们代码最开始都是以这两个内置的作为最顶层的partent context，衍生出更多的子Context。

var (
    background = new(emptyCtx)
    todo = new(emptyCtx)
)

func Background() Context {
    return background
}

func TODO() Context {
    return todo
}

一个是Background，主要用于main函数、初始化以及测试代码中，作为Context这个树结构的最顶层的Context，也就是根Context。

一个是TODO，它目前还不知道具体的使用场景，如果我们不知道该使用什么Context的时候，可以使用这个。

他们两个本质上都是emptyCtx结构体类型，是一个不可取消，没有设置截止时间，没有携带任何值的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
}

这就是emptyCtx实现Context接口的方法，可以看到，这些方法什么都没做，返回的都是nil或者零值。

Context的继承衍生

有了如上的根Context，那么是如何衍生更多的子Context的呢，这就靠context包为我们提供的with系列的函数了。

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

func WithValue(parent Context, key, value interface{}) Context

这4个with函数，接收的都有一个partent参数，就是父Context，我们要基于这个父Context创建出子Context的意思，这个方式可以理解为子Context对父Context的继承，也可以理解为基于父Context的衍生。

通过这些函数，就创建了一颗Context树，树的每个节点都可以有任意多个子节点，节点层级可以有任意多个。

WithCancel函数，传递一个父Context作为参数，返回子Context，以及一个取消函数用于取消Context。

WithDeadline函数，和WithCancel差不多，它会多传递一个截止时间参数，意味着到了这个时间点，会自动取消Context，当然我们也可以不等到这个时候，可以提前通过取消函数进行取消。

WithTimeout和WithDeadine基本一样，这个表示是表示超时自动取消，是多少时间后自动取消Context的意思。

WithValue函数和取消Context无关，它是为了生成一个绑定了一个键值对数据的Context，这个绑定的数据可以通过Context.Value 方法访问到。

前三个函数都返回一个取消函数CancelFunc， 这是一个函数类型，它的定义非常简单。

type CancelFunc func()

这就是取消函数的类型，该函数可以取消一个Context，以及这个节点Context下所有的Context。

WithValue传递元数据

通过Context 我们也可以传递一些必须的元数据，这些数据会附加在Context上以供使用。

var key string="name"

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    valueCtx := context.WithValue(ctx, key, "123")

    go watch(valueCtx)

    cancel()
}

func watch(ctx context.Context) {
    for {
        select {
        case <- ctx.Done();
            fmt.Println(ctx.Value(key))
            return
        default:
            fmt.Println(ctx.Value(key))    
        }
    }
}

Context使用原则

• 1.不要把Context放在结构体中，要以参数的方式传递
• 2.以Context作为参数的函数方法，应该把Context作为第一个参数，放在第一位。
• 3.给一个函数方法传递Context的时候，不要传递nil，如果不知道传递什么，就使用context.TODO
• 4.Context的Value相关方法应该传递必须的数据，不要什么数据都使用这个传递
• 5.Context是线程安全的，可以放心的在多个goroutine中传递

源码学习

package context

import (
    "errors"
    "internal/reflectlite"
    "sync"
    "sync/atomic"
    "time"
)

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key any) any
}

var Canceled = errors.New("context canceled")

var DeadlineExceeded error = deadlineExceededError{}
type deadlineExceededError struct{}


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
}

var (
    background = new(emptyCtx)
    todo = new(emptyCtx)
)

func Background() Context {
    return background
}

func TODO() Context {
    return todo
}

type cancelCtx struct {
    Context

    mu sync.Mutex
    done atomic.Value
    children map[canceler]struct{}
    err error 
}

type CancelFunc func()

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
    if parent == nil {
        panic("cannot create context from nil parent")
    }
    c := newCancelCtx(parent)


}

func newCancelCtx(parent Context) cancelCtx {
    return cancelCtx{Context: parent}
}