本文作者：anker

前言

context.Context 非常重要！
context.Context 非常重要！
context.Context 非常重要！

源码

go1.17.6的 context.Context 源码，建议所有 golang developer 都读一读，在旧版本没有那么多解释文字，在最新的版本补充了很详细的说明，甚至样例，足以说明 context.Context 在 golang 中的重要性。

这里大概讲解一下提供的方法及其作用，后面会详细举例

如果暂时不想阅读源码，可以先跳过这小节，后面都会讲到。当然自行看看会更加清晰！

Context 存在的意义？

先给一个定论：Context 用于协程生命周期的管理，包括值传递，控制传递。

首先我们先来看看 context 包的常用方法

• func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)
• func WithValue(parent Context, key, val interface{}) Context
• func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
• func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

不难看出，上面几个方法，通过父 Context 和一些参数派生出新的 Context 和 CancelFunc（非必须）。这里 CancelFunc 的作用是通知新的 Context 以及往后通过他派生出来的 Context 进行结束。

cancel 行为

那么通过派生行为，可以把 Context 管理的值和控制行为传递下去。

那么 Context 的作用，其实也很明显了：

举例

参数传递

这里以 http 请求通过 Context 传递 requestId 到日志组件作为例子，下面是样例代码。

样例代码

package main

import (
    "context"
    "fmt"
    "github.com/gin-gonic/gin"
    "log"
    "net/http"
    "sync/atomic"
)

const requestIdCtxKey = "requestIdCtxKey"

func main() {
    counter := uint64(0)
    r := gin.Default()
    r.Use(func(c *gin.Context) {
        // gin.Context 也实现了 context.Context interface
        requestId := atomic.AddUint64(&counter, 1)
        // 给每个请求设置 requestId
        c.Set(requestIdCtxKey, requestId)
    })

    r.GET("/", func(c *gin.Context) {
        // 读取相应内容，以 ctx.Context 读取
        getResponseMessage := func(ctx context.Context, username string) (message string) {
            message = fmt.Sprintf("hello %s!", username)
            logFunc(ctx, "response:"+message)
            return
        }

        // 直接把 gin.Context 传入
        message := getResponseMessage(c, c.DefaultQuery("user", "guest"))

        logFunc(c, "url:"+c.Request.URL.RequestURI())
        c.String(http.StatusOK, message)
    })
    r.Run(":12222")
}

func logFunc(ctx context.Context, message string) {
    requestId := ctx.Value(requestIdCtxKey)
    id := requestId.(uint64)
    log.Printf("requestId:%d message:%s\n", id, message)
}

执行命令：

curl http://127.0.0.1:12222/?user=anker

http输出：
hello anker!

标准输出：
2022/04/03 21:18:43 requestId:1 message:response:hello anker!
2022/04/03 21:18:43 requestId:1 message:url:/?user=anker

控制传递

这里以控制协程结束为例，下面是样例代码

package main

import (
    "context"
    "log"
    "sync"
    "time"
)

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

    // 五秒后通知 ctx 结束
    time.AfterFunc(5*time.Second, func() {
        cancel()
    })

    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        ticker := time.NewTicker(1 * time.Second)
        defer ticker.Stop()
        for ok := true; ok; {
            select {
            case <-ctx.Done():
                // 监听到结束，设置循环结束条件
                ok = false
                if ctx.Err() != nil {
                    // 输出退出原因
                    log.Println("context done,error:", ctx.Err().Error())
                }
            case <-ticker.C:
            }

            if !ok {
                continue
            }

            // 每1秒输出一次
            log.Println("goroutine 1 ticker:", time.Now().Unix())
        }
    }()

    wg.Add(1)
    go func() {
        defer wg.Done()
        // 监听ctx结束
        <-ctx.Done()
        log.Println("goroutine 2 end")

    }()

    wg.Wait()
    log.Println("exit ok")
}

标准输出：

2022/04/03 21:32:50 goroutine 1 ticker: 1648992770
2022/04/03 21:32:51 goroutine 1 ticker: 1648992771
2022/04/03 21:32:52 goroutine 1 ticker: 1648992772
2022/04/03 21:32:53 goroutine 1 ticker: 1648992773
2022/04/03 21:32:54 goroutine 2 end
2022/04/03 21:32:54 goroutine 1 ticker: 1648992774
2022/04/03 21:32:54 context done,error: context canceled
2022/04/03 21:32:54 exit ok

延伸开来，可以通过在函数调用链中传递 Context ，实现在上层函数一些机制（超时、可用性检测）通知下层方法尽快结束。

例如 Mysql 查询，Redis 操作，调用这些组件的库一般都会提供 Context 作为函数第一个值，其实就是用作控制行为传递。

而且强烈建议 Context 作为函数的参数时，放第一个参数位置。

最后

通过一些样例，现在应该对 Context 有更深的了解了。不妨再滑动上去看看源码中关于 Context 的注释，会有更深刻的认识。