2.24 Go之Context(上下文)

2.24 Go之Context(上下文)

Context的涵义

Goroutine的上下文，包含Goroutine的运行状态、环境、现场等信息

作用：

并发控制和超时控制的标准做法

Context的定义

程序单元的一个运行状态、现场、快照

特点：

• 上下是指存在上下层的传递

• 上会把内容传递给下

• 程序单元则指的是Goroutine

运行过程

每个Goroutine在执行之前，都要先知道程序当前的执行状态，通常将这些执行状态封装在一个Context变量中，传递给要执行的 Goroutine中

网络编程中，在收到一个请求Request需要开启不同的Goroutine来获取数据和逻辑处理。--->请求一个Request会在多个Goroutine中处理：

• 这些Goroutine需要共享Request信息。

• 当Request被取消或者超时的时候，所有从这个Request创建的所有Goroutine也应该被结束

Context接口

Context包核心：

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

• Deadline方法需要返回当前Context被取消的时间，也就是完成工作的截止时间（deadline）；

• Done方法需要返回一个Channel，Channel会在当前工作完成或者上下文被取消之后关闭，多次调用Done方法会返回同一个Channel；

• Err方法会返回当前Context结束的原因，只会在Done返回的Channel被关闭时才会返回非空的值：

• 如果当前Context被取消就会返回Canceled错误；

• 如果当前Context超时就会返回DeadlineExceeded错误；

• Value方法会从Context中返回键对应的值，对于同一个上下文来说，多次调用Value并传入相同的Key会返回相同的结果，该方法仅用于传递跨API和进程间跟请求域的数据。

Background()和TODO()

特点：

Go语言内置的两个函数：分别返回一个实现了Context接口的background和todo

Background()函数的作用：

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

background和todo本质上都是emptyCtx结构体类型，是一个不可取消，没有设置截止时间，没有携带任何值的Context

With系列函数

• WithChannel

• WithDeadline

• WithTimeout

• WithValue

---

WithChannel

返回带有新Done通道的父节点副本。调用返回的cancel函数或当关闭父上下文的Done通道时，将关闭返回上下文的Done通道，无论先发生什么情况。取消此上下文将释放与其关联的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel

示例代码：

设计一个gen函数，在单独的Goroutine中生成整数并将它们发送到返回的通道。gen的调用者在使用生成的整数之后要取消上下文，以免gen启动的内部Goroutine发生泄漏

package main
​
import (
    "context"
    "fmt"
)
​
/*
设计一个`gen`函数，在单独的`Goroutine`中生成整数并将它们发送到返回的通道。
`gen`的调用者在使用生成的整数之后要取消上下文，以免`gen`启动的内部`Goroutine`发生泄漏
 */
func main() {
    gen := func(ctx context.Context) <-chan int {
        // 定义整数
        dst := make(chan int)
        n := 1
        // 开启一个goroutine
        go func() {
            // 循环生成整数并发送到返回的通道
            for {
                select {
                case <-ctx.Done():
                    // 结束该routine,防止泄露
                    return
                case dst <- n:
                    n++
                }
            }
        }()
        return dst
    }
​
    // 调用withchannel函数关闭通道
    ctx, cancel := context.WithCancel(context.Background())
    // 取完需要的整数后调用cancel函数
    defer cancel()
​
    for n := range gen(ctx) {
        fmt.Println(n)
        if n == 5 {
            break
        }
    }
}

WithDeadline

返回父上下文的副本，将deadline调整为不迟于d，如果父上下文的deadline早于d，则WithDeadline(parent, d)在语义上等同于父上下文。当截止日过期时，当调用返回的cancel函数时，或者当父上下文的Done通道关闭时，返回上下文的Done通道将被关闭，以最先发生的情况为准

示例代码：

取消此上下文将释放与其关联的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel

package main
​
import (
    "context"
    "fmt"
    "time"
)
​
func main() {
    // 设置一个超时的deadline
    d := time.Now().Add(50 * time.Millisecond)
    // 调用withdeadline函数在超过时间以后结束goroutine
    ctx, cancel := context.WithDeadline(context.Background(), d)
​
    // 尽管ctx会过期，但在任何情况下调用它的cancel函数都是很好的实践。
    // 如果不这样做，可能会使上下文及其父类存活的时间超过必要的时间。
    /* 执行cancel函数 */
    defer cancel()
​
    // 使用select选择器根据情况执行代码
    select {
    case <-time.After(1 * time.Second):
        fmt.Println("overslept")
    case <-ctx.Done():
        fmt.Println(ctx.Err())
    }
}

代码解析：

定义了一个50毫秒之后过期的deadline

调用context.WithDeadline(context.Background(), d)得到一个上下文（ctx）和一个取消函数（cancel），

使用一个select让主程序陷入等待

等待1秒后打印overslept退出

或者

等待ctx过期后退出。因为ctx 50秒后就过期，所以ctx.Done()会先接收到值，然后打印ctx.Err()取消原因。

WithTimeout

返回WithDeadline(parent, time.Now().Add(timeout))

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

示例代码：

取消此上下文，释放与其相关的资源。代码应该在此上下文中运行的操作完成后立即调用cancel：

package main
​
import (
    "context"
    "fmt"
    "time"
)
​
func main() {
    // 传递超时的上下文信息
    ctx, cancel := context.WithTimeout(context.Background(), 50 * time.Microsecond)
​
    // 告诉阻塞函数在超时结束后应该放弃其工作--->调用取消函数
    defer cancel()
​
    // 通过select选择执行的函数
    select {
    case <-time.After(1 * time.Second):
        fmt.Println("overslept")
    case <-ctx.Done():
        // 终端输出"context deadline exceeded"
        fmt.Println(ctx.Err())
    }
}

WithValue

将请求作用域的数据与Context对象建立关系：

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

接收context 并返回派生的context。其中val与key关联，通过context树与context一起传递。一旦获得带有值的context，从中派生的任何context都会获得此值。不建议使用context值传递关键参数

示例代码：

提供的key必须是可比较的，不应该是string类型或者任何其他内置类型。避免使用上下文在包之间发生冲突。WithValue的用户应该为键定义自己的类型，为了避免在分配给接口{ }时进行分配，上下文键通常具有具体类型struct{}。或者，导出的上下文关键变量的静态类型应该是指针或接口。

package main
​
import (
    "context"
    "fmt"
)
​
func main() {
    // 定义一个key类型
    type favContextKey string
​
    // 定义一个变量，从上下文中获取key和value的函数
    f := func(ctx context.Context, k favContextKey) {
        // 判断key值
        if v := ctx.Value(k); v != nil {
            fmt.Println("查询到的值是:", v)
            return
        }
        fmt.Println("找不到键:", k)
    }
    // 创建默认k
    k := favContextKey("language")
    // 创建一个携带key为k，value为"Go"的上下文
    ctx := context.WithValue(context.Background(), k, "Go")
​
    // 调用f函数
    f(ctx, k)
    f(ctx, favContextKey("color"))
}

使用Context的注意事项：

• 不要把Context放在结构体中，要以参数的方式显示传递；

• 以Context作为参数的函数方法，应该把Context作为第一个参数；

• 给一个函数方法传递Context的时候，不要传递nil，如果不知道传递什么，就使用context.TODO；

• Context的Value相关方法应该传递请求域的必要数据，不应该用于传递可选参数；

• Context是线程安全的，可以放心的在多个Goroutine中传递。

总结

Context的主要作用是在多个Goroutine或者模块之间同步取消信号或者截止日期，减少对资源消耗和长时间占用。

不能将请求的所有参数都使用Context进行传递。比较常见的使用场景是传递请求对应用户的认证令牌以及用于进行分布式追踪的请求ID