往期精选（欢迎转发~~）
11.1 内容前导
回顾之前的知识，我们先看一个关于WaitGroup的示例：
func main() {var wg sync.WaitGroupwg.Add(2)go func() {time.Sleep(2*time.Second)fmt.Println("1号完成")wg.Done()}()go func() {time.Sleep(2*time.Second)fmt.Println("2号完成")wg.Done()}()wg.Wait()fmt.Println("好了，大家都干完了，放工")}
示例比较简单，main协程等待两个goroutine的结束。如果是希望主协程关闭，通知goutoutine关闭，我们可以使用select + chan的方式：
func main() {stop := make(chan bool)go func() {for {select {case <-stop:fmt.Println("监控退出，停止了...")returndefault:fmt.Println("goroutine监控中...")time.Sleep(2 * time.Second)}}}()time.Sleep(10 * time.Second)fmt.Println("可以了，通知监控停止")stop<- true//为了检测监控过是否停止，如果没有监控输出，就表示停止了time.Sleep(5 * time.Second)}
这种chan+select的方式，是比较优雅的结束一个goroutine的方式，不过这种方式也有局限性，如果有很多goroutine都需要控制结束怎么办呢？如果这些goroutine又衍生了其他更多的goroutine怎么办呢？如果一层层的无穷尽的goroutine呢？这就非常复杂了，即使我们定义很多chan也很难解决这个问题，因为goroutine的关系链就导致了这种场景非常复杂。
上面说的这种场景是存在的，比如一个网络请求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("监控退出，停止了...")returndefault:fmt.Println("goroutine监控中...")time.Sleep(2 * time.Second)}}}(ctx)time.Sleep(10 * time.Second)fmt.Println("可以了，通知监控停止")cancel()//为了检测监控过是否停止，如果没有监控输出，就表示停止了time.Sleep(5 * time.Second)}
当执行cancel()时，goroutine会接收到ctx.Done()的信号，协程退出，对于控制多个goroutine的示例如下：
func main() {ctx, cancel := context.WithCancel(context.Background())go watch(ctx,"【监控1】")go watch(ctx,"【监控2】")go watch(ctx,"【监控3】")time.Sleep(10 * time.Second)fmt.Println("可以了，通知监控停止")cancel()//为了检测监控过是否停止，如果没有监控输出，就表示停止了time.Sleep(5 * time.Second)}func watch(ctx context.Context, name string) {for {select {case <-ctx.Done():fmt.Println(name,"监控退出，停止了...")returndefault:fmt.Println(name,"goroutine监控中...")time.Sleep(2 * time.Second)}}}
11.2 基础知识
11.2.1 Context接口
Context的接口定义的比较简洁，我们看下这个接口的方法：
type Context interface {Deadline() (deadline time.Time, ok bool)Done() <-chan struct{}Err() errorValue(key interface{}) interface{}}
这个接口共有4个方法，了解这些方法的意思非常重要，这样我们才可以更好的使用他们：
Deadline方法是获取设置的截止时间的意思，第一个返回式是截止时间，到了这个时间点，Context会自动发起取消请求；第二个返回值ok==false时表示没有设置截止时间，如果需要取消的话，需要调用取消函数进行取消。
Done方法返回一个只读的chan，类型为struct{}，我们在goroutine中，如果该方法返回的chan可以读取，则意味着parent context已经发起了取消请求，我们通过Done方法收到这个信号后，就应该做清理操作，然后退出goroutine，释放资源。
Err方法返回取消的错误原因，因为什么Context被取消。
Value方法获取该Context上绑定的值，是一个键值对，所以要通过一个Key才可以获取对应的值，这个值一般是线程安全的。
11.2.2 顶层Context
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 intfunc (*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或者零值。
11.2.3 子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, val interface{}) Context
这四个With函数，接收的都有一个partent参数，就是父Context，我们要基于这个父Context创建出子Context的意思，这种方式可以理解为子Context对父Context的继承，也可以理解为基于父Context的衍生。通过这些函数，就创建了一颗Context树，树的每个节点都可以有任意多个子节点，节点层级可以有任意多个。
WithCancel函数，传递一个父Context作为参数，返回子Context，以及一个取消函数用来取消Context。
WithDeadline函数，和WithCancel差不多，它会多传递一个截止时间参数，意味着到了这个时间点，会自动取消Context，当然我们也可以不等到这个时候，可以提前通过取消函数进行取消。
WithTimeout和WithDeadline基本上一样，这个表示是超时自动取消，是多少时间后自动取消Context的意思。
WithValue函数和取消Context无关，它是为了生成一个绑定了一个键值对数据的Context，这个绑定的数据可以通过Context.Value方法访问到，后面我们会专门讲。
大家可能留意到，前三个函数都返回一个取消函数CancelFunc，这就是取消函数的类型，该函数可以取消一个Context，以及这个节点Context下所有的所有的Context，不管有多少层级。
11.2.4 元数传递
通过Context我们也可以传递一些必须的元数据，这些数据会附加在Context上以供使用。
var key string="name"func main() {ctx, cancel := context.WithCancel(context.Background())//附加值valueCtx:=context.WithValue(ctx,key,"【监控1】")go watch(valueCtx)time.Sleep(10 * time.Second)fmt.Println("可以了，通知监控停止")cancel()//为了检测监控过是否停止，如果没有监控输出，就表示停止了time.Sleep(5 * time.Second)}func watch(ctx context.Context) {for {select {case <-ctx.Done()://取出值fmt.Println(ctx.Value(key),"监控退出，停止了...")returndefault://取出值fmt.Println(ctx.Value(key),"goroutine监控中...")time.Sleep(2 * time.Second)}}}
在前面的例子，我们通过传递参数的方式，把name的值传递给监控函数。在这个例子里，我们实现一样的效果，但是通过的是Context的Value的方式。我们可以使用context.WithValue方法附加一对K-V的键值对，这里Key必须是等价性的，也就是具有可比性；Value值要是线程安全的。这样我们就生成了一个新的Context，这个新的Context带有这个键值对，在使用的时候，可以通过Value方法读取ctx.Value(key)。
11.3 知识扩展
这里我们主要先讨论一下撤销的操作。Done方法会返回一个元素类型为struct{}的接收通道，不过，这个接收通道的用途并不是传递元素值，而是让调用方去感知“撤销”当前Context值的那个信号，一旦当前的Context值被撤销，这里的接收通道就会被立即关闭，因为对于一个未包含任何元素值的通道来说，它的关闭会使任何针对它的接收操作立即结束。这里解释的可能有点绕，或者换句话来说，如果Context取消的时候，它其实主要是关闭chan，关闭的chan是可以读取的，所以只要可以读取的时候，就意味着可以通过Done收到Context取消的信号了。
除了让Context值的使用方感知到撤销信号，让它们得到“撤销”的具体原因，有时也是很有必要的。后者即是Context类型的Err方法的作用。该方法的结果是error类型的，并且其值只可能等于context.Canceled变量的值，或者context.DeadlineExceeded变量的值，我们看一个经典用法：
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值会先关闭它内部的接收通道，也就是它的Done方法会返回的那个通道。然后，它会向它的所有子值（或者说子节点）传达撤销信号，这些子值会如法炮制，把撤销信号继续传播下去。最后，这个Context值会断开它与其父值之间的关联。先看一幅图：
我们通过调用context包的WithDeadline函数或者WithTimeout函数生成的Context值也是可撤销的。它们不但可以被手动撤销，还会依据在生成时被给定的过期时间，自动地进行定时撤销，这里定时撤销的功能是借助它们内部的计时器来实现的。当过期时间到达时，这两种Context值的行为与Context值被手动撤销时的行为是几乎一致的，只不过前者会在最后停止并释放掉其内部的计时器。最后要注意，通过调用context.WithValue函数得到的Context值是不可撤销的，撤销信号在被传播时，若遇到它们则会直接跨过，并试图将信号直接传给它们的子值。
11.4 实战场景：上下游调用
package mainimport ("context""fmt""math/rand""time")// 作用：1.随机sleep一会；2.如果入参ch不为空，会把sleep的时间给到chfunc sleepRandom(fromFunction string, ch chan int) {defer func() { fmt.Println(fromFunction, "sleepRandom complete") }()seed := time.Now().UnixNano()r := rand.New(rand.NewSource(seed))randomNumber := r.Intn(100)sleeptime := randomNumber + 100fmt.Println(fromFunction, "Starting sleep for", sleeptime, "ms")time.Sleep(time.Duration(sleeptime) * time.Millisecond)fmt.Println(fromFunction, "Waking up, slept for ", sleeptime, "ms")if ch != nil {ch <- sleeptime}}func sleepRandomContext(ctx context.Context, ch chan bool) {defer func() {fmt.Println("sleepRandomContext complete")// 通过channel，通知上游执行完毕ch <- true}()sleeptimeChan := make(chan int)// 开启新的协程G2，让该协程执行逻辑，执行完毕后，通过sleeptimeChan通知执行完毕go sleepRandom("sleepRandomContext", sleeptimeChan)select {case <-ctx.Done():// 场景1：main()调用cancelFunction()// 场景2：doWorkContext()调用cancelFunction()// 场景3：doWorkContext()自动超时fmt.Println("sleepRandomContext: Time to return")case sleeptime := <-sleeptimeChan:// 当新的协程G2执行完毕，调用ch<-sleeptime时fmt.Println("Slept for ", sleeptime, "ms")}}func doWorkContext(ctx context.Context) {// 生成新的ctx，超时时间为150msctxWithTimeout, cancelFunction := context.WithTimeout(ctx, time.Duration(150)*time.Millisecond)defer func() {fmt.Println("doWorkContext complete")// 下游所有的ctx都会关闭cancelFunction()}()ch := make(chan bool)// 启动新的协程G1go sleepRandomContext(ctxWithTimeout, ch)select {case <-ctx.Done():// 当main退出，调用main的cancelFunction()时fmt.Println("doWorkContext: Time to return")case <-ch:// 当新的协程G1退出，执行ch<-true时fmt.Println("sleepRandomContext returned")}}func main() {ctx := context.Background()ctxWithCancel, cancelFunction := context.WithCancel(ctx)defer func() {fmt.Println("Main Defer: canceling context")// 下游所有的ctx都会关闭cancelFunction()}()go func() {// main函数sleep一会sleepRandom("Main", nil)// 下游所有的ctx都会关闭cancelFunction()fmt.Println("Main Sleep complete. canceling context")}()doWorkContext(ctxWithCancel)}
对于上面这个示例，我描述一下每种场景：
场景1：main函数调用cancelFunction()后，main()会直接退出，同时doWorkContext和sleepRandomContext函数会同时调用里面的ctx.Done()操作，全部一起退出；
场景2：doWorkContext函数超时150ms后，sleepRandomContext函数会直接执行ctx.Done()操作，然后sleepRandomContext函数退出前执行ch <- true，doWorkContext函数接收到case <-ch的信号后，doWorkContext()退出，main()退出；
场景3：sleepRandomContext函数执行sleepRandom()，当sleepRandom执行ch <- sleeptime后，sleepRandomContext通过sleeptime := <-sleeptimeChan收到信号后，程序退出，退出前会执行ch <- true，然后doWorkContext函数接收到case <-ch的信号后，doWorkContext()退出，main()退出；
场景4：main()异常，通过defer执行cancelFunction()后，main()退出，后面逻辑同“场景1”；
场景5：doWorkContext()异常，通过defer执行cancelFunction()后，sleepRandomContext函数会直接执行ctx.Done()操作，sleepRandomContext()退出，cancelFunction()退出，main()退出；
场景6：sleepRandomContext异常，通过defer执行ch <- true，doWorkContext函数接收到case <-ch的信号后，doWorkContext()退出，main()退出；
前面3个是正常场景，后面3个是异常场景，无论哪种场景，设计思路是，当前函数退出时，下游所有context需要全部关闭，这个是依赖context可传递的特性，同时也能通知上游“我已经关闭了，请你继续你后续的操作”。
11.5 总结
我们今天主要讨论的是context包中的函数和Context类型，该包中的函数都是用于产生新的Context类型值的，Context类型是一个可以帮助我们实现多goroutine 协作流程的同步工具，不但如此，我们还可以通过此类型的值传达撤销信号或传递数据。
Context类型的实际值大体上分为三种，即：根Context值、可撤销的Context值和含数据的Context值。所有的Context值共同构成了一颗上下文树，这棵树的作用域是全局的，而根Context值就是这棵树的根，它是全局唯一的，并且不提供任何额外的功能。
可撤销的Context值又分为：只可手动撤销的Context值，和可以定时撤销的Context值，我们可以通过生成它们时得到的撤销函数来对其进行手动的撤销。对于后者，定时撤销的时间必须在生成时就完全确定，并且不能更改，不过我们可以在过期时间达到之前，对其进行手动的撤销，一旦撤销函数被调用，撤销信号就会立即被传达给对应的Context值，并由该值的Done方法返回的接收通道表达出来。“撤销”这个操作是Context值能够协调多个 goroutine 的关键所在，撤销信号总是会沿着上下文树叶子节点的方向传播开来。含数据的Context值不能被撤销，而可撤销的Context值又无法携带数据，由于它们共同组成了一个有机的整体（即上下文树），所以在功能上要比sync.WaitGroup强大得多。
