Golang | 一文带你快速入门context

Posted 2021-09-04 灭BUG

前言

Go1.7引入了context包，其中定义了多种上下文，包括可主动取消的上下文，带截止时间或超时时间的上下文，带值传播的上下文

context包的引入意义非凡， 它可以让信息（如：用户信息）在协程之间传递变得更加便捷，也可以把控一组协程的退出时机

假设，当前有一个函数gen，它接受context入参，作用是创建一个无缓冲区的channel，起一个协程每秒往这个通道中塞入一个信号，当context结束时，关闭通道，协程正常退出

func gen(ctx context.Context) chan struct{} {
    c := make(chan struct{})
    go func() {
        for {
            select {
            case <-ctx.Done(): // [1]context结束
                fmt.Println("receive context done signal, closing channel now")
                close(c) // 关闭通道
                return // groutine正常退出
            default:
                c <- struct{}{} // [2]使用空结构体节省内存
            }
            time.Sleep(time.Second)
        }
    }()
    return c
}

接下来，通过几个简单的例子来体验一下context包提供的各种类型的上下文

例子1：可主动取消的上下文

通过context包WithCancel函数，可以创建一个支持主动取消的上下文

func UseCancelContext() {
    ctx, cancelFunc := context.WithCancel(context.Background())
    go func() {
        time.AfterFunc(time.Second*5, func() {
      // [1] 五秒后执行取消上下文的操作
            cancelFunc()
            fmt.Println("send context done signal")
        })
    }()
    for range gen(ctx) {
        fmt.Println("receive signal from another goroutine")
    }
    fmt.Println("main goroutine is finished")
}

[1]处主动调用cancelFunc，其底层逻辑就是关闭当前上下文及其子上下文中的通道，当上下文中的通道被关闭时，<-ctx.Done()就会有值，gen函数中的select会选择case <-ctx.Done()，然后执行关闭通道，退出协程

函数执行结果如下，可以看到，gen函数中的协程在发送了五次信号后，关闭了通道，正常退出协程

<img src="https://images-1255831004.cos.ap-guangzhou.myqcloud.com/online/2021-07-05-132126.png" style="zoom:50%;" />

例子2：带截止时间的上下文

通过context包WithDeadline函数，可以创建一个带截止时间的上下文

func UseDeadlineContext() {
  // 创建一个截止时间为五秒后的上下文
    ctx, cancelFunc := context.WithDeadline(context.Background(), time.Now().Add(time.Second*5))
    defer cancelFunc() // [1]请思考一下为什么要这样做？
    for range gen(ctx) {
        fmt.Println("receive signal from another goroutine")
    }
    fmt.Println("main goroutine is finished")
}

上述函数创建了一个截止时间为五秒后的上下文，该上下文会在五秒后关闭通道

<img src="https://images-1255831004.cos.ap-guangzhou.myqcloud.com/online/2021-07-05-133503.png" style="zoom:50%;" />

例子3：带超时时间的上下文

通过context包WithTimeout函数，可以创建一个带超时时间的上下文

func UseTimeoutContext() {
    ctx, cancelFunc := context.WithTimeout(context.Background(), time.Second*5)
    defer cancelFunc()
    for range gen(ctx) {
        fmt.Println("receive signal from another goroutine")
    }
    fmt.Println("main goroutine is finished")
}

上述函数中创建了一个带五秒超时时间的上下文，代码执行结果

<img src="https://images-1255831004.cos.ap-guangzhou.myqcloud.com/online/2021-07-05-133737.png" style="zoom:50%;" />

例子4：带值传播的上下文

通过context包WithValue函数，可以创建一个带值传播的上下文

func UseValueContext() {
  // 创建一个带值的上下文,键值对<1,"value">
    ctx := context.WithValue(context.Background(), 1, "value")
    c := make(chan struct{})
    go func() {
        time.Sleep(time.Second * 1)
    // 从上下文中获取对应的值
        value := ctx.Value(1)
        fmt.Printf("get value from ctx, value = %s\\n", value)
        c <- struct{}{}
    }()
    <-c
    fmt.Println("main goroutine is finished")
}

执行结果

<img src="https://images-1255831004.cos.ap-guangzhou.myqcloud.com/online/2021-07-05-134207.png" style="zoom:50%;" />

总结

日常开发中需要使用context包的场景非常多，简单举几个例子：

1. 从请求上下文中获取用户信息
2. 从请求上下文中获取请求的唯一标识（traceId，常用于分布式日志追踪）
3. 控制请求超时时间

可以看到，通过context包，我们更容易实现信息在一组协程之间的传播，也更好地把控多个协程的退出时机

Go也重写了很多标准库来支持context包

同时Go官方建议上下文不应该嵌入到结构体中使用，而是应该将上下文作为调用函数/方法的第一个参数使用，并推荐参数命名为ctx

// 不推荐
type ModuleContext struct {
  c context.Context
}
// 推荐
func func1(ctx context.Context, opts ...Option)

掌握这个包的使用和了解其中原理是很有必要的

下一篇文章我将会解答在这篇文章中的留下的疑问（例子2 [1] 处），以及进一步挖掘context包源码