初始
Go1.7加入了一个新的 标准库context,它定义了context类型,专门用来简化对于处理单个请求的多个go协程之间与请求域的数据、取消信号、截止时间等相关操作。
对服务器传入的请求应该创建上下文，而对服务器的传出调用应该接收上下文。他们之间的函数调用链必须传递上下文，或者可以使用withcancel、withdeadline、withtimeout或withvalue创建的派生上下文。当一个上下文被取消时，他派生的上下文也被取消。
context接口
context.Context是一个接口，该接口定义了四个需要实现的方法。
type Context interface {
Deadline() (deadline time.Time, ok bool)
Done() <-chan struct{}
Err() error
Value(key interface{}) interface{}
}
- Deadline方法需要返回当前Context被取消的时间,也就是完成工作的截止时间。
- Done方法需要返回一个Channel,这个Channel会在当前工作完成或者上下文被取消之后关闭，多次调用Done方法会返回同一个Channel
- Err方法会返回当前context结束的原因,他会在Done返回的Channel被关闭时才会返回非空的值。
- 如果当前context被取消就会返回Canceled错误；
- 如果当前context超时就会返回DeadlineExceeded错误
- value方法会从context中返回键对应的值，对于同一个上下文来说，多次调用value并传入相同的key会返回相同的结果,该方法仅用于传递跨API和进程间跟请求域的数据；
Background和Todo方法
go内置两个函数；backgroud()和todo(),这两个都实现了context接口,代码中顶层的parent context都是靠这两个生成的并衍生更多子上下文
background和todo本质都是emptyctx结构体类型,是一个不可取消，没有设置截止时间,没有携带任何值的context
with系列函数
withcancel
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
withcancel返回带有新Done通道的父节点副本，当调用返回的cancel函数或当关闭父上下文的Done通道时，将关闭返回上下文的Done通道，无论发生什么情况。
案例:
package main
import (
"context"
"fmt"
)
func gen(ctx context.Context) <-chan int {
dst := make(chan int)
n := 1
go func() {
for {
select {
case <-ctx.Done():
return //return结束go协程，防止泄露
case dst <- n:
n++
}
}
}()
return dst
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
for n := range gen(ctx) {
fmt.Println(n)
if n == 5 {
break
}
}
}
withDeadline
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)
案例:
package main
import (
"context"
"fmt"
"time"
)
func main() {
d := time.Now().Add(3 * time.Second)
ctx, cancel := context.WithDeadline(context.Background(), d)
go watch(ctx, "监控1")
go watch(ctx, "监控2")
fmt.Println("现在开始等待5秒,time=", time.Now())
time.Sleep(5 * time.Second)
fmt.Println("等待5秒结束,准备调用cancel函数,发现两个go协程已经结束，time=", time.Now())
cancel()
}
func watch(ctx context.Context, name string) {
for {
select {
case <-ctx.Done():
fmt.Println(name, "收到信号，监控退出")
return
default:
fmt.Println(name, "goroutine监控中")
time.Sleep(1 * time.Second)
}
}
}
结果:
监控1 goroutine监控中
监控2 goroutine监控中
现在开始等待5秒,time= 2022-05-13 10:46:34.3675909 +0800 CST m=+0.005482901
监控1 goroutine监控中
监控2 goroutine监控中
监控1 goroutine监控中
监控2 goroutine监控中
监控1 收到信号，监控退出
监控2 收到信号，监控退出
等待5秒结束,准备调用cancel函数,发现两个go协程已经结束，time= 2022-05-13 10:46:39.3903594 +0800 CST m=+5.028251401
WithDeadline返回父上下文的副本，到了过期时间或调用cancel函数，Done通道将被关闭，以最先发生的情况为准。
上述案例，设置了3秒过期的父本，并开启两个协程，3秒到了，即使还没有调用cancel函数，2个协程都收到Done信号，并结束。等到5秒调用cancel函数发现2个协程已经结束。不过不调用cancel函数，可能会使上下文及其父类活动的时间超过必要的时间，。
withTimeout
源码：
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
return WithDeadline(parent, time.Now().Add(timeout))
}
可以看到，返回的是WithDeadline,只是时间参数不一样。
WithValue
源码：
func WithValue(parent Context, key, val any) Context
案例：
package main
import (
"context"
"fmt"
"sync"
"time"
)
// context.WithValue
type TraceCode string
var wg sync.WaitGroup
func worker(ctx context.Context) {
key := TraceCode("TRACE_CODE")
traceCode, ok := ctx.Value(key).(string) // 在子goroutine中获取trace code
if !ok {
fmt.Println("invalid trace code")
}
LOOP:
for {
fmt.Printf("worker, trace code:%s\n", traceCode)
time.Sleep(time.Millisecond * 10) // 假设正常连接数据库耗时10毫秒
select {
case <-ctx.Done(): // 50毫秒后自动调用
break LOOP
default:
}
}
fmt.Println("worker done!")
wg.Done()
}
func main() {
// 设置一个50毫秒的超时
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
// 在系统的入口中设置trace code传递给后续启动的goroutine实现日志数据聚合
ctx = context.WithValue(ctx, TraceCode("TRACE_CODE"), "12512312234")
wg.Add(1)
go worker(ctx)
time.Sleep(time.Second * 5)
cancel() // 通知子goroutine结束
wg.Wait()
fmt.Println("over")
}
结果:
worker, trace code:12512312234
worker, trace code:12512312234
worker done!
over
注意事项
- 推荐以参数的方式显示传递context
- 在函数方法中，context作为第一个参数
- 给一个函数方法传递context时候，不要传递nil，如果不知道穿什么，就使用context.TODO
- context的value相关方法应该 传递请求域的必要数据，不应该传递可选参数
- context是线程安全的，可以放心在多个go协程中传递
