Go上下文标准库Context
目录
- 全局变量退出协程
- channel退出协程
- context退出协程
- Context
- Background()和TODO()
- Context接口
- With系列函数
-
- WithCancel
- WithDeadline
- WithTimeout
- WithValue
- 使用Context的注意事项
- 函数结束协程结束吗
- Context使用场景
-
- 客户端超时取消示例
- 每秒更新 1 次外卖小哥的位置
- http传递共享的数据threading-local
-
- 简单版
- 复杂版
- 控制10s后，所有协程退出
- 控制某个go协程执行5次就结束
- 打印100个素数
- 防止 goroutine 泄漏
-
- 泄露例子
- context优化
- 整体类图
当一个请求被取消或超时时，所有用来处理该请求的 goroutine 都应该迅速退出，然后系统才能释放这些 goroutine 占用的资源。
全局变量退出协程
package main
import (
"fmt"
"sync"
"time"
)
var wg sync.WaitGroup
var exit bool
// 全局变量方式存在的问题：
// 1. 使用全局变量在跨包调用时不容易统一
// 2. 如果worker中再启动goroutine，就不太好控制了。
func worker() {
for {
fmt.Println("worker")
time.Sleep(time.Second)
if exit {
break
}
}
wg.Done()
}
func main() {
wg.Add(1)
go worker()
time.Sleep(time.Second * 3) // sleep3秒以免程序过快退出
exit = true // 修改全局变量实现子goroutine的退出
wg.Wait()
fmt.Println("over")
}
channel退出协程
package main
import (
"fmt"
"sync"
"time"
)
var wg sync.WaitGroup
// 管道方式存在的问题：
// 1. 使用全局变量在跨包调用时不容易实现规范和统一，需要维护一个共用的channel
func worker(exitChan chan struct{}) {
LOOP:
for {
fmt.Println("worker")
time.Sleep(time.Second)
select {
case <-exitChan: // 等待接收上级通知
break LOOP
default:
}
}
wg.Done()
}
func main() {
var exitChan = make(chan struct{})
wg.Add(1)
go worker(exitChan)
time.Sleep(time.Second * 3) // sleep3秒以免程序过快退出
exitChan <- struct{}{} // 给子goroutine发送退出信号
close(exitChan)
wg.Wait()
fmt.Println("over")
}
context退出协程
package main
import (
"context"
"fmt"
"sync"
"time"
)
var wg sync.WaitGroup
func worker(ctx context.Context) {
LOOP:
for {
fmt.Println("worker")
time.Sleep(time.Second)
select {
case <-ctx.Done(): // 等待上级通知
break LOOP
default:
}
}
wg.Done()
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
wg.Add(1)
go worker(ctx)
time.Sleep(time.Second * 3)
cancel() // 通知子goroutine结束
wg.Wait()
fmt.Println("over")
}
Context
-
Go 1.7 标准库引入 context 包，中文翻译为 “上下文”，准确说它是 goroutine 的上下文，它包含 goroutine 的运行状态、环境、现场等信息。
-
context 主要用来在 goroutine 之间传递上下文信息，包括：取消信号、超时时间、截止时间、共享数据等。
-
专门用来简化对于处理单个请求的多个 goroutine 之间与请求域的数据、取消信号、截止时间等相关操作，这些操作可能涉及多个 API 调用。
-
服务器传入的请求应该创建上下文，而对服务器的传出调用应该接受上下文。它们之间的函数调用链必须传递上下文，或者可以使用WithCancel、WithDeadline、WithTimeout或WithValue创建的派生上下文。
-
当一个上下文被取消时，它派生的所有上下文也被取消。
Background()和TODO()
-
Go内置两个函数：Background()和TODO()，这两个函数分别返回一个实现了Context接口的background和todo。代码中最开始都是以这两个内置的上下文对象作为最顶层的partent context，衍生出更多的子上下文对象。
-
Background()主要用于main函数、初始化以及测试代码中，作为Context这个树结构的最顶层的Context，也就是根Context，它没有任何功能，不能被取消，没有值，也没有超时时间。
-
TODO()，它目前还不知道具体的使用场景，如果我们不知道该使用什么Context的时候，可以使用这个。
-
background和todo本质上都是emptyCtx结构体类型，是一个不可取消，没有设置截止时间，没有携带任何值的Context。
Context接口
-
context.Context是一个接口，该接口定义了四个需要实现的方法。
type Context interface { // Deadline方法需要返回当前Context被取消的时间，也就是完成工作的截止时间（deadline）； Deadline() (deadline time.Time, ok bool) // Done方法需要返回一个Channel，这个Channel会在当前工作完成或者上下文被取消之后关闭，多次调用Done方法会返回同一个Channel； Done() <-chan struct{} // Err方法会返回当前Context结束的原因，它只会在Done返回的Channel被关闭时才会返回非空的值； Err() error // Value方法会从Context中返回键对应的值，对于同一个上下文来说，多次调用Value 并传入相同的Key会返回相同的结果，该方法仅用于传递跨API和进程间跟请求域的数据； Value(key interface{}) interface{} } -
在 Go 语言程序中，关闭协程可以通过 channel+select 方式实现，而不是直接杀死协程。
-
但是在某些场景下，例如某个请求衍生了很多协程，这些协程之间是相互关联，共享一些全局变量、有共同的生命周期，而且需要同时关闭，再用 channel+select 就会比较繁琐，而且有可能出现协程泄露问题。
-
类似的场景，就可以通过 context 来实现。
-
其实 context 源码中也是通过 channel+select 来实现的，而且内部还构造了一棵派生关系树，便于生命周期、广播通知等管理，所以我们无需再造轮子。
-
有了根节点 Context，可以使用它作为参数，使用 context 包提供的四个函数创建子节点 Context：
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系列函数
WithCancel
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
-
WithCancel 函数的参数是父Context。
-
WithCancel 的返回值是父Context的副本 ctx 和一个取消函数 CancelFunc。
-
当返回的取消函数被调用时，或者父Context的 Done 通道被关闭时，返回的Context的 Done 通道将被关闭，顺序以最先发生的为准。
-
取消此上下文将释放与其关联的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel。
func gen(ctx context.Context) <-chan int {
dst := make(chan int)
n := 1
go func() {
for {
select {
case <-ctx.Done():
return // return结束该goroutine，防止泄露
case dst <- n:
n++
}
}
}()
return dst
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
// 当我们取完需要的整数后调用cancel
defer cancel()
for n := range gen(ctx) {
fmt.Println(n)
if n == 5 {
break
}
}
}
WithDeadline
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
-
WithDeadline 函数的参数是父Context 和 截止时间 deadline。
-
WithDeadline 的返回值是父Context的副本 ctx 和一个取消函数 CancelFunc。
-
当协程运行到截止时间、返回的取消函数被调用，或者父Context的 Done 通道被关闭时，返回的Context的 Done 通道将被关闭。
-
返回父上下文的副本，并将deadline调整为不迟于d。如果父上下文的deadline已经早于d，则WithDeadline(parent, d)在语义上等同于父上下文。当截止日过期时，当调用返回的cancel函数时，或者当父上下文的Done通道关闭时，返回上下文的Done通道将被关闭，以最先发生的情况为准。
package main
import (
"context"
"time"
)
func contextTest(ctx context.Context) {
for {
select {
case <-ctx.Done():
// 被取消或者超时就结束协程
println("goroutin finished")
return
default:
}
// 每隔 1 秒钟，打印 running
time.Sleep(time.Second)
println("running")
}
}
func main() {
// 3 秒后自动取消运行中的协程
ctx, _ := context.WithDeadline(context.Background(),time.Now().Add(3 * time.Second))
go contextTest(ctx)
// 等待 5 秒钟，让 contextTest 协程优雅结束。
time.Sleep(5*time.Second)
}
func main() {
d := time.Now().Add(50 * time.Millisecond)
ctx, cancel := context.WithDeadline(context.Background(), d)
// 尽管ctx会过期，但在任何情况下调用它的cancel函数都是很好的实践。
// 如果不这样做，可能会使上下文及其父类存活的时间超过必要的时间。
defer cancel()
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()会先接收到context到期通知，并且会打印ctx.Err()的内容。
WithTimeout
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
-
WithTimeout 函数的参数是父Context 和 超时时间 timeout。
-
WithTimeout 的返回值是父Context的副本 ctx 和一个取消函数 CancelFunc。
-
当协程运行时间超过 timeout、返回的取消函数被调用，或者父Context的 Done 通道被关闭时，返回的Context的 Done 通道将被关闭。
-
取消此上下文将释放与其相关的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel，通常用于数据库或者网络连接的超时控制。
ar wg sync.WaitGroup
func worker(ctx context.Context) {
LOOP:
for {
fmt.Println("db connecting ...")
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)
wg.Add(1)
go worker(ctx)
time.Sleep(time.Second * 5)
cancel() // 通知子goroutine结束
wg.Wait()
fmt.Println("over")
}
WithValue
func WithValue(parent Context, key, val interface{}) Context
-
WithValue 函数的参数是父Context 和 key、val。key 和 val是一个键值对。
-
WithValue 的返回值是父Context的副本 ctx。
-
WithValue 仅对传递进程和api的请求范围内的数据使用上下文值，而不是将可选参数传递给函数。
-
提供的键必须是可比较的，不要使用字符串类型或任何其他内置类型，以避免使用上下文的包之间的冲突，使用者应该定义他们自己的键类型，通常为具体 struct{} 类型。或者，导出的上下文键变量的静态类型应该是一个指针或接口。
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")
}
使用Context的注意事项
- 不要将 Context 塞到结构体里，而是直接将 Context 类型作为函数的第一参数，而且一般都命名为 ctx。
- 不要向函数传入一个 nil 的 Context，如果你实在不知道传什么，标准库给你准备好了一个 context.TODO()。
- 不要把本应该作为函数参数的类型塞到 Context Context 存储的应该是一些共同的数据。例如：登陆的 session、cookie 等。
- 同一个 Context 可能会被传递到多个 goroutine，别担心，Context 是并发安全的。
函数结束协程结束吗
- main函数中的协程，如果main结束了，协程也会结束，其他函数里的协程，函数结束了，只要main没结束，协程就会执行。
- Go语言中，若在子go程中创建一个新 go程，子go程释放（销毁），新创建的go程不会随着子go程的销毁而销毁。（go程共享堆，不共享栈，go程由程序员在go的代码里显示调度（释放），子go程的栈被释放（回收），由于栈独立，因此新创建的go程的栈不会被释放。）
- Go语言中，若在主go程中创建一个新 go程，主go程释放（销毁），新创建的go程随着主go程的销毁而销毁。（go程共享堆，不共享栈，go程由程序员在go的代码里显示调度（释放）。）
综上：主main退出的话，全部的协程也就退出了。
Context使用场景
- 推荐以参数的方式显示传递Context
- 以Context作为参数的函数方法，应该把Context作为第一个参数。
- 给一个函数方法传递Context的时候，不要传递nil，如果不知道传递什么，就使用context.TODO()
- Context的Value相关方法应该传递请求域的必要数据，不应该用于传递可选参数
- Context是线程安全的，可以放心的在多个goroutine中传递
客户端超时取消示例
package main
import (
"context"
"fmt"
"io/ioutil"
"net/http"
"sync"
"time"
)
// 客户端
type respData struct {
resp *http.Response
err error
}
func doCall(ctx context.Context) {
transport := http.Transport{
// 请求频繁可定义全局的client对象并启用长链接
// 请求不频繁使用短链接
DisableKeepAlives: true, }
client := http.Client{
Transport: &transport,
}
respChan := make(chan *respData, 1)
req, err := http.NewRequest("GET", "http://127.0.0.1:8000/", nil)
if err != nil {
fmt.Printf("new requestg failed, err:%v\n", err)
return
}
req = req.WithContext(ctx) // 使用带超时的ctx创建一个新的client request
var wg sync.WaitGroup
wg.Add(1)
defer wg.Wait()
go func() {
resp, err := client.Do(req)
fmt.Printf("client.do resp:%v, err:%v\n", resp, err)
rd := &respData{
resp: resp,
err: err,
}
respChan <- rd
wg.Done()
}()
select {
case <-ctx.Done():
//transport.CancelRequest(req)
fmt.Println("call api timeout")
case result := <-respChan:
fmt.Println("call server api success")
if result.err != nil {
fmt.Printf("call server api failed, err:%v\n", result.err)
return
}
defer result.resp.Body.Close()
data, _ := ioutil.ReadAll(result.resp.Body)
fmt.Printf("resp:%v\n", string(data))
}
}
func main() {
// 定义一个100毫秒的超时
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
defer cancel() // 调用cancel释放子goroutine资源
doCall(ctx)
}
每秒更新 1 次外卖小哥的位置
// 功能
func Perform(ctx context.Context) {
for {
calculatePos()
sendResult()
// 监听哪个通道有响应
// 没有就阻塞，完成响应就开启下一次循环
select {
case <-ctx.Done():
// 被取消，直接返回
return
case <-time.After(time.Second):
// block 1 秒钟
}
}
}
// main
ctx, cancel := context.WithTimeout(context.Background(), time.Hour)
go Perform(ctx)
// ……
// app 端返回页面，调用cancel 函数
cancel()
WithTimeOut 函数返回的 context 和 cancelFun 是分开的。context 本身并没有取消函数，这样做的原因是取消函数只能由外层函数调用，防止子节点 context 调用取消函数，从而严格控制信息的流向：由父节点 context 流向子节点 context。
http传递共享的数据threading-local
对于 Web 服务端开发，往往希望将一个请求处理的整个过程串起来，这就非常依赖于 Thread Local（对于 Go 可理解为单个协程所独有） 的变量，而在 Go 语言中并没有这个概念，因此需要在函数调用的时候传递 context。
简单版
package main
import (
"context"
"fmt"
)
func main() {
ctx := context.Background()
process(ctx)
ctx = context.WithValue(ctx, "traceId", "codebaoku-2021")
process(ctx)
}
func process(ctx context.Context) {
traceId, ok := ctx.Value("traceId").(string)
if ok {
fmt.Printf("process over. trace_id=%s\n", traceId)
} else {
fmt.Printf("process over. no trace_id\n")
}
}
process over. no trace_id
process over. trace_id=codebaoku-2021
复杂版
const requestIDKey int = 0
func WithRequestID(next http.Handler) http.Handler {
return http.HandlerFunc(
func(rw http.ResponseWriter, req *http.Request) {
// 从 header 中提取 request-id
reqID := req.Header.Get("X-Request-ID")
// 创建 valueCtx。使用自定义的类型，不容易冲突
ctx := context.WithValue(
req.Context(), requestIDKey, reqID)
// 创建新的请求
req = req.WithContext(ctx)
// 调用 HTTP 处理函数
next.ServeHTTP(rw, req)
}
)
}
// 获取 request-id
func GetRequestID(ctx context.Context) string {
ctx.Value(requestIDKey).(string)
}
func Handle(rw http.ResponseWriter, req *http.Request) {
// 拿到 reqId，后面可以记录日志等等
reqID := GetRequestID(req.Context())
...
}
func main() {
// 自定义handler
handler := WithRequestID(http.HandlerFunc(Handle))
http.ListenAndServe("/", handler)
}
控制10s后，所有协程退出
使用context包来实现线程安全退出或超时的控制:控制10s后，所有协程退出
package main
import (
"context"
"fmt"
"strconv"
"sync"
"time"
)
func task(ctx context.Context, s string, wg *sync.WaitGroup) {
defer wg.Done()
for {
select {
case <-ctx.Done():
fmt.Println(s, "--->我结束了")
//fmt.Println(ctx.Err())
return
default:
fmt.Println(s)
time.Sleep(1 * time.Second)
}
}
}
func main() {
var wg sync.WaitGroup
ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
for i := 0; i < 10; i++ {
wg.Add(1)
s := fmt.Sprintf("我是第：%v 个任务", strconv.Itoa(i))
go task(ctx, s, &wg)
}
wg.Wait()
}
当并发体超时或main主动停止工作者Goroutine时，每个工作者都可以安全退出。
控制某个go协程执行5次就结束
// 控制goroutine 执行5次结束
func main() {
// 定义一个运行次数变量
runCount := 0
//定义一个waitgroup，等待goroutine执行完成
var wg sync.WaitGroup
// 初始化context
parent := context.Background()
// 传入初始化的ctx，返回ctx和cancle函数
ctx, cancle := context.WithCancel(parent)
wg.Add(1) // 增加一个任务
go func() {
for {
select {
case <-ctx.Done():
fmt.Println("任务结束")
return
default:
fmt.Printf("任务执行了%d次\n", runCount)
runCount++
}
// 执行了5次，使用ctx的取消函数将任务取消
if runCount >= 5 {
cancle()
wg.Done() // goroutine执行完成
}
}
}()
wg.Wait() //等待所有任务完成
}
打印100个素数
Go语言是带内存自动回收特性的，因此内存一般不会泄漏。当main函数不再使用管道时后台Goroutine有泄漏的风险。我们可以通过context包来避免这个问题，下面是防止内存泄露的素数筛实现：
// 返回生成自然数序列的管道: 2, 3, 4, ...
func GenerateNatural(ctx context.Context) chan int {
ch := make(chan int)
go func() {
for i := 2; ; i++ {
select {
//父协程cancel()时安全退出该子协程
case <- ctx.Done():
return
//生成的素数发送到管道
case ch <- i:
}
}
}()
return ch
}
// 管道过滤器: 删除能被素数整除的数
func PrimeFilter(ctx context.Context, in <-chan int, prime int) chan int {
out := make(chan int)
go func() {
for {
if i := <-in; i%prime != 0 {
select {
//父协程cancel()时安全退出该子协程
case <- ctx.Done():
return
case out <- i:
}
}
}
}()
return out
}
func main() {
// 使用一个可由父协程控制子协程安全退出的Context。
ctx, cancel := context.WithCancel(context.Background())
ch := GenerateNatural(ctx) // 自然数序列: 2, 3, 4, ...
for i := 0; i < 100; i++ {
// 新出现的素数打印出来
prime := <-ch
fmt.Printf("%v: %v\n", i+1, prime)
// 基于新素数构造的过滤器
ch = PrimeFilter(ctx, ch, prime)
}
//输出100以内符合要求的素数后安全退出所有子协程
cancel()
}
当main函数完成工作前，通过调用cancel()来通知后台Goroutine退出，这样就避免了Goroutine的泄漏。
防止 goroutine 泄漏
泄露例子
当 n == 5 的时候，直接 break 掉。那么 gen 函数的协程就会执行无限循环，永远不会停下来。发生了 goroutine 泄漏。
func gen() <-chan int {
ch := make(chan int)
go func() {
var n int
for {
ch <- n
n++
time.Sleep(time.Second)
}
}()
return ch
}
func main() {
for n := range gen() {
fmt.Println(n)
if n == 5 {
break
}
}
// ……
}
context优化
func gen(ctx context.Context) <-chan int {
ch := make(chan int)
go func() {
var n int
for {
select {
case <-ctx.Done():
return
case ch<- n:
n++
time.Sleep(time.Second)
}
}
}()
return ch
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
defer cancel() // 避免其他地方忘记 cancel，且重复调用不影响
for n := range gen(ctx) {
fmt.Println(n)
if n == 5 {
cancel()
break
}
}
// ……
}
- 增加一个 context，在 break 前调用 cancel 函数，取消 goroutine。
- gen 函数在接收到取消信号后，直接退出，系统回收资源。（有可能发出退出信号时，gen正在sleep，但sleep完后，立马会退出）
整体类图
