context：协调多个goroutine

Posted 2021-03-14 traditional

什么是context

context是golang在1.7版本的时候引入的标准库，从名字也知道是"上下文"，不过准确的说应该是goroutine的上下文，它包含了goroutine的运行状态、环境等信息。

context主要是用来在goroutine之间传递上下文信息，包括：取消信号、超时时间、截止时间等等。

为什么会有context

我们在context之前一般会使用WaitGroup来协调多个协程，但是WaitGroup要求的是多个协程必须都完成，那么才算完成，否则就会一直阻塞。

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    wg := new(sync.WaitGroup)
    wg.Add(3)
    go func() {
        time.Sleep(time.Second)
        fmt.Println("任务1完成")
        wg.Done()
    }()

    go func() {
        time.Sleep(time.Second * 3)
        fmt.Println("任务2完成")
        wg.Done()
    }()

    go func() {
        time.Sleep(time.Second * 2)
        fmt.Println("任务3完成")
        wg.Done()
    }()

    wg.Wait()
    fmt.Println("任务都完成了，收工")
    /*
    任务1完成
    任务3完成
    任务2完成
    任务都完成了，收工
     */
}

我们看到只有当3个任务都完成才算完成，否则wg.Wait()就会一直阻塞在那里，所以WaitGroup就是控制一组goroutine。但是实际上，我们会碰到这样一种场景，我们需要主动地通知某个goroutine让其退出。比如有一个goroutine一直在监视某个资源的变化，但是现在不需要了，于是我们就需要主动地通知它，让其退出，否则很容易造成内存泄露。

但是现在问题来了，我们知道当一个goroutine启动之后，我们是无法控制它的，大部分情况是等待它自己结束。但如果是一个不会自己结束的一个goroutine呢？比如：我需要一个goroutine不断监视某个目录，如果有新文件，那么就进行相应的逻辑，但是只需要监视三天，三天之后就不需要监视这个目录了，那么我们就应该让这个goroutine停掉。目前可以使用chan + select：

package main

import (
    "fmt"
    "time"
)

func main() {

    go func() {
        for {
            select {
                //其他逻辑

                //这里假设是3s吧，3s后，这个goroutine就退出了
                case <-time.After(time.Second * 3):
                    fmt.Println("3s已到，这个goroutine已经退出")
                    return
            }
        }
    }()

    for {}
    /*
    3s已到，这个goroutine已经退出
     */
}

再比如说，可以在满足指定的条件之后，让goroutine退出。

package main

import (
    "fmt"
)

func main() {
    quitCh := make(chan int)
    go func(quitCh chan int) {
        for {
            select {
                //其他逻辑

                //我们看到，如果我们想让这个goroutine退出，那么就给quitCh这个channel发送一个值即可。
                case <-quitCh:
                    fmt.Println("这个goroutine已经退出")
                    return
            }
        }
    }(quitCh)

    fmt.Println("程序执行中······")
    //退出goroutine
    quitCh <- 0
    for {}
    /*
    程序执行中······
    这个goroutine已经退出
     */
}

我们看到这种chan+select是一种比较优雅地结束一个goroutine的方式，但是它有一个缺点，如果有很多的goroutine的结束都需要控制该怎么办？另外这些goroutine又衍生了其他的goroutine怎么办？即使我们定义了很多chan也很难解决这些问题，因为goroutine的关系链就导致了这种场景十分复杂。

所以我们才需要有context。

初识context

我们上面说的那种场景是真实存在的，比如一个网络请求Request，每个Request都需要开启一个goroutine做一些事情，而这些goroutine又需要开启其他的goroutine，所以我们就需要一种可以跟踪goroutine的方案，才可以达到控制它们的目的。context包就是为了解决上面的问题而开发的：使用context可以在一组goroutine之间传递共享的值、取消信号、deadline······。

总结一下就是：在go里面我们不能直接杀死协程，协程的关闭一般会使用channel+select的方式。但是在某些场景下，例如处理一个请求衍生了许多协程，这些协程之间是互联的：需要共享一些全局变量、有共同的deadline等等，而且可以同时被关闭再用 channel+select 就会比较麻烦，这时就可以通过 context 来实现。

一句话：context 用来解决goroutine之间退出通知、 元数据传递的功能。

package main

import (
    "context"
    "fmt"
    "time"
)

func goroutine1(ctx context.Context){
    for {
        select {
        case <-ctx.Done():
            fmt.Println("goroutine1完成任务，退出")
            return
        default:
            fmt.Println("goroutine1工作中")
            time.Sleep(time.Second * 3)
        }
    }
}

func goroutine2(ctx context.Context){
    for {
        select {
        case <-ctx.Done():
            fmt.Println("goroutine2完成任务，退出")
            return
        default:
            fmt.Println("goroutine2工作中")
            time.Sleep(time.Second * 2)
        }
    }
}

func goroutine3(ctx context.Context){
    for {
        select {
        case <-ctx.Done():
            fmt.Println("goroutine3完成任务，退出")
            return
        default:
            fmt.Println("goroutine3工作中")
            time.Sleep(time.Second * 4)
        }
    }
}


func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go goroutine1(ctx)
    go goroutine2(ctx)
    go goroutine3(ctx)
    time.Sleep(time.Second * 10)
    fmt.Println("时间到，通知所有goroutine退出")
    cancel()
    /*
    goroutine1工作中
    goroutine3工作中
    goroutine2工作中
    goroutine2工作中
    goroutine1工作中
    goroutine3工作中
    goroutine2工作中
    goroutine1工作中
    goroutine2工作中
    goroutine3工作中
    goroutine2工作中
    goroutine1工作中
    时间到，通知所有goroutine退出
     */
}

仔细观察代码的话，应该不难理解。ctx.Done()是一个channel，当我们调用cancel()的时候，是可以从里面读取数据的。但是我们发现，所有的goroutine都退出了，这就是Context的一个特点，会对每一个goroutine都进行跟踪，当我们使用cancel函数通知取消的时候，Context跟踪的goroutine都会被结束。这就是Context的控制能力，它就像一个控制器一样，按下开关后，所有基于这个Context或者衍生的子Context都会收到通知，这时就可以进行清理操作了，最终释放goroutine，这就优雅的解决了goroutine启动后不可控的问题。

下面我们再来看看context.WithCancel(context.Background())这一句是干嘛的，首先我们知道肯定返回了一个Context对象和一个函数，context.Background() 返回一个空的Context，这个空的Context一般用于整个Context树的根节点。然后我们使用context.WithCancel(parent)函数，创建一个可取消的子Context，然后当作参数传给goroutine使用，这样就可以使用这个子Context跟踪这个goroutine。

Context接口

Context是一个接口，里面定义了四个方法，并且它们都是幂等的，也就是说连续调用多次得到的结果都是相同的。

type Context interface {
    //返回一个截止时间和一个布尔值。
    //到达指定的时间点，Context会自动发起取消请求，此时ok是true。
    //如果ok==false，那么表示没有设置截止时间，如果需要取消的话，就需要手动调用取消函数进行取消
    Deadline() (deadline time.Time, ok bool)
    //返回一个只读的channel，类型为struct{}，我们在goroutine中，如果该方法返回的channel可以读取，则意味着parent context已经发起了取消请求。
    //然后通过Done方法收到这个信号之后，可以做一些清理操作，然后退出goroutine，释放资源。
    Done() <-chan struct{}
    //返回一个错误原因，因为什么导致Context被取消
    Err() error
    //获取该Context上绑定的值，是一个键值对，所以要通过一个Key才可以获取对应的值，这个值一般是线程安全的。
    Value(key interface{}) interface{}
}

以上四个方法中常用的就是Done了，如果Context取消的时候，我们就可以得到一个关闭的chan，关闭的chan是可以读取的，所以只要可以读取的时候，就意味着收到Context取消的信号了，所以Context监视的所有goroutine才能都接收到信号。以下是这个方法的经典用法：

package main

import (
    "context"
    "fmt"
    "time"
)

func goroutine1(ctx context.Context){
    for {
        select {
        case <-ctx.Done():
            //等待退出的信号
            fmt.Println("收到取消通知，我要退出啦，使命已经结束")
            return
        default:
            //什么也不做，为了select不阻塞
        }
        
        //todo: 努力工作
        func(){
            time.Sleep(time.Second * 3)
            fmt.Println("bob，别傻愣着")
        }()
    }
}


func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go goroutine1(ctx)
    time.Sleep(time.Second * 9)
    fmt.Println("结束啦~~~~，通知协程退出")
    cancel()
    //可能要忙其他的事情
    for {}
    /*
    bob，别傻愣着
    bob，别傻愣着
    结束啦~~~~，通知协程退出
    bob，别傻愣着
    收到取消通知，我要退出啦，使命已经结束
     */
}

Context的接口不需要我们实现，Go内置了两个。

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, val interface{}) Context

这四个With函数，都接收了一个parent参数，也就是父Context，我们要基于这个父Context创建出子Context的意思，这种方式可以理解为子Context对父Context的继承，也可以理解为基于父Context的衍生。通过这些函数，就创建了一颗Context树，树的节点都可以有任意多个子节点，节点层级可以有任意多个。

WithCancel函数，传递一个父Context作为参数，返回子Context，以及一个取消函数用来取消Context。 WithDeadline函数，和WithCancel差不多，它会多传递一个截止时间参数，意味着到了这个时间点，会自动取消Context，当然我们也可以不等到这个时候，可以提前通过取消函数进行取消。而WithTimeout和WithDeadline基本上一样，这个表示是超时自动取消，是多少时间后自动取消Context的意思。可以把前面的WithDeadline理解为到达指定的时间点取消，WithTimeout理解为达到指定的时间间隔取消。

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

大家可能留意到，前三个函数都返回一个取消函数CancelFunc，这是一个函数类型，它的定义非常简单。

type CancelFunc func()

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

WithValue传递元数据

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

package main

import (
    "context"
    "fmt"
    "time"
)

func goroutine1(ctx context.Context){
    for {
        select {
        case <-ctx.Done():
            //等待退出的信号
            fmt.Println("收到取消通知，我要退出啦，使命已经结束")
            fmt.Printf("拿到传入的值:%s", ctx.Value("name"))
            return
        default:
            //什么也不做，为了select不阻塞
        }

        //todo: 努力工作
        func(){
            time.Sleep(time.Second * 3)
            fmt.Println("bob，别傻愣着")
        }()
    }
}


func main() {
    ctx, cancel := context.WithCancel(context.TODO())
    //这里是基于返回的ctx进行创建的，接收三个参数：Context，interface{}，interface{}
    valueCtx := context.WithValue(ctx, "name", "satori")
    //传入的不再是ctx，而是基于ctx新创建的valueCtx
    go goroutine1(valueCtx)
    time.Sleep(time.Second * 9)
    fmt.Println("结束啦~~~~，通知协程退出")
    //调用cancel()的时候，不光是<-ctx.Done()可以获取数据，<-valueCtx.Done()一样可以获取数据
    cancel()
    //可能要忙其他的事情
    for {}
    /*
    bob，别傻愣着
    bob，别傻愣着
    结束啦~~~~，通知协程退出
    bob，别傻愣着
    收到取消通知，我要退出啦，使命已经结束
    拿到传入的值:satori
     */
}

我们可以使用context.WithValue方法附加一对K-V的键值对，这里Key必须是等价性的，也就是具有可比性；Value值要是线程安全的。这样我们就生成了一个新的Context，这个新的Context带有这个键值对，在使用的时候，可以通过Value方法读取ctx.Value(key)。记住，使用WithValue传值，一般是必须的值，不要什么值都传递

context使用原则

1.Do not store Contexts inside a struct type; instead, pass a Context explicitly to each function that needs it. The Context should be the first parameter, typically named ctx.
2.Do not pass a nil Context, even if a function permits it. Pass context.TODO if you are unsure about which Context to use.
3.Use context Values only for request-scoped data that transits processes and APIs, not for passing optional parameters to functions.
4.The same Context may be passed to functions running in different goroutines; Contexts ar safe for simultaneous use by multiple goroutines.

1.不要将 Context 塞到结构体里。直接将 Context 类型作为函数的第一个参数，而且一般都命名为 ctx。
2.不要向函数传入一个 nil 的 context，如果你实在不知道传什么，标准库给你准备好了一个 context：todo。
3.不要把本应该作为函数参数的类型塞到 context 中，context 存储的应该是一些共同的数据。例如：登陆的 session、cookie 等。
4.同一个 context 可能会被传递到多个 goroutine，别担心，context 是并发安全的。

参考

码农桃花源：https://mp.weixin.qq.com/s/GpVy1eB5Cz_t-dhVC6BJNw

飞雪无情：https://www.flysnow.org/2017/04/29/go-in-action-go-runner.html