context包
context包介绍
在go语言中,每个独立调用一般都会被单独的协程处理。但在处理一个请求时,往往可能需要在多个协程之间进行信息传递,甚至包括一层层地递进顺序传递,而且这种信息往往具有一定的场景状态。如一个请求可能衍生出各个协程之间需要满足一定的约束关系,如登录状态,前一个协程的计算结果、传递请求全局变量等功能
go语言为开发人员提供了一个解决方案,即标准的context包,有的地方也称为上下文。使用上下文可以在多个协程之间传递请求相关的数据、主动取消上下文或按照时间自动取消上下文等。
每个协程在执行之前,一般都需要了解当前的执行状态,通常会将这些状态包装在上下文变量中进行传递。上下文几乎已经成为传递与Request同生命周期的变量的标准方法。
当程序接收到一个网络请求的Request,在处理Request时,可能需要开启不同的协程来获取数据与逻辑处理,即一个请求Request,可能需要在多个协程中被处理。这些协程需要共享Request的一些信息,同时当顶层Context被取消或者超时的时候,所有从这个顶层Request创建的Context也应该结束。这些都可以通过Context来实现,Context就像是Request中的全局变量能让大家共享数据,当然实际上它是需要创建并传递的。
context包实现了在程序协程之间共享状态变量的方法,在被调用程序单元的外部,通过设置上下文变量ctx,将过期或取消信号传递给被调用的程序单元。
Context包中定义的Context结构如下所示:
//Context包包含过期、取消信号、request值传递等,方法在多个协程中线程安全
type Context interface {
// Done方法在context被取消或者超时返回一个close的channel
Done() <-chan struct{}
Err() error
//Deadline返回context超时时间
Deadline()(deadline time.Time, ok bool)
//Value返回context相关key对应的值
Value(key interface{}) interface{}
}
- Deadline会返回一个超时时间,超时后Context无效
- Done方法返回一个通道(channel),当Context被取消或过期时,该通道关闭,即它是一个表示是否已关闭的信号
- 当Done通道关闭后,Err方法表明Context被取消的原因
- Value是可以共享的数据
Context的创建和调用关系总是层层递进的,就像社会组织的层级一样,Context创建者的协程可以主动关闭其下层的Context的执行。为了实现这种关系,Context结构就像一颗树,叶子节点总是由根节点衍生出来的。
要创建上下文树,第一步就是要得到根节点,context.Background函数的返回值就是根节点:
func Background() Context
Background()函数返回空的上下文,该上下文一般由接收请求的第一个协程创建,作为进入请求对应的上下文根节点,它不能被取消,没有值,也没有过期时间。它常常作为处理Requests的顶层上下文存在。
有了根节点,又该怎么创建其他的子节点、孙节点呢?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 interface{}, val interface{})Context
这些函数都接收一个Context类型的参数parent,并返回一个Context类型的值,这样就层层创建出不同的节点。父节点创建Context,并传递给子节点。
怎么通过Context传递改变的状态呢?使用Context的协程是无法取消某个操作的,只有父协程可以取消操作。在父协程中可以通过WithCancel函数获得一个CancelFunc函数类型变量,从而可以手工取消这个Context。
WithCancel函数将父节点Context复制到子节点,并且返回一个额外的CancelFunc函数类型变量,该函数类型的定义为:
type CancelFunc func()
调用CancelFunc对象cancel将取消对应的Context对象,这就是主动取消Context的方法。在父节点的Context所对应的环境中,通过WithCancel函数不仅可以创建节点的Context,同时也获得了该节点Context的控制权,一旦执行该函数取消,该节点Context就结束了,而子节点则需要根据context.Done()来判断是否结束。例如:
select{
case <-ctx.Done():
}
WithDeadline函数的作用也差不多,它返回的Context类型值同样是parent的副本,但其过期时间由deadline和parent的过期时间共同决定。这是因为父节点过期时,其所有的子孙节点必须同时关闭;反之,返回的父节点的过期时间则为deadline.
WithTimeout函数与WithDeadline类似,不过它传入的是上下文从现在开始剩余的生命时长。它们同样也都返回了所创建的上下文的控制权及一个CancelFunc类型的函数变量。
当顶层的Request请求函数结束后,就可以取消某个上下文,从而再对应协程中根据ctx.Done()来决定是否结束协程本身。
WithValue函数返回parent的一个副本,调用该副本的Value(key)方法将得到对应的key的值。不光可以将根节点原有的值保留,还可以在子孙节点中加入新的值,注意若存在新、旧Key相同的情况,则旧key的值会被覆盖。
Context对象的生存周期一般仅为一个请求的处理周期,即针对一个请求创建一个Context变量(它是上下文树结构的根)。在请求处理结束后,撤销此变量,释放资源。
每次创建一个协程时,可以将原有的上下文传递给这个子协程,或者新创建一个子上下文传递给这个协程。
上下文能灵活地存储不同类型,不同数目的值,并且使多个协程安全的读写其中的值。
当通过父Context对象创建子上下文对象时,即可获得子上下文的一个取消函数,这样父上下文对象的创建环境就获得了对子上下文的撤销权。
使用上下文时需遵循以下规则。
(1)上下文变量需要作为第一个参数使用,一般命名为ctx
(2)不要传入一个nil的上下文,不确定Context时可传一个context.TODO
(3)使用上下文的Value相关方法只传递请求相关的元数据,不要传递可选参数。
(4)同样的上下文可以用来传递到不同的协程中,上下文在多个协程中是安全的。
在子上下文被传递到的协程中,应该对该子上下文的Done通道(channel)进行监控,一旦该通道被关闭(即上层运行环境撤销了本协程的执行),应主动终止对当前请求信息的处理,释放资源并返回。
使用context同步信号
我们可以通过一个代码片段了解context.Context
是如何对信号进行同步的。在这段代码中,我们创建了一个过期时间为1s的上下文,并向上下文传入handle
函数,
该方法会使用500ms的时间处理传入的请求:
func main(){
ctx, cancel := context.WithTimeout(context.Background(), 1 * time.Second)
defer cancel()
go handle(ctx, 500 * time.Millisecond)
select {
case <-ctx.Done():
fmt.Println("main", ctx.Err())
}
}
func handle(ctx context.Context, duration time.Duration){
select {
case <-ctx.Done():
fmt.Println("handle", ctx.Err())
case <-time.After(duration):
fmt.Println("process request with", duration)
}
}
因为过期时间大于处理时间,所以我们有足够的时间处理该请求
process request with 500ms
main context deadline exceeded
handle
函数没有进入超时的select分支,但是main
函数的select
却会等待context.Context
超时并打印出main context deadline exceeded
如果我们将处理请求时间增加至1500ms,整个程序都会因为上下文过期而被终止:
main context deadline exceeded
handle context deadline exceeded
默认上下文
context
包中最常用的方法还是context.Background
、context.TODO
,这两个方法都会返回预先初始化好的私有变量background
和todo
,它们
会在同一个go程序中被复用:
func Background() Context{
return background
}
func TODO() Context{
return todo
}
这两个私有变量都是通过new(emptyCtx)
语句初始化的,它们是指向私有结构体context.emptyCtx
的指针,这是最简单、最常用的上下文类型:
type emptyCtx int
func (*emptyCtx) Deadline() (deadline time.Time, ok bool){
return
}
func (*emptyCtx) Done() <-chan struct{} {
return nil
}
func (*emptyCtx) Err() error{
return nil
}
func (*emptyCtx) Value(key interface{})interface{}{
return nil
}
从上述代码中,我们不难发现 context.emptyCtx 通过空方法实现了 context.Context 接口中的所有方法,它没有任何功能。
context层级关系
从源码来看,context.Background
和context.TODO
也只是互为别名,没有太大的差别,只是在使用和语义上稍有不同:
context.Background
是上下文的默认值,所有其他的上下文都应该从它衍生出来context.TODO
应该仅在不确定应该使用哪种上下文时使用;
在多数情况下,如果当前函数没有上下文作为入参,我们都会使用context.Background
作为起始的上下文向下传递
上下文应用
前面介绍协程时,对协程的管理和控制并没有进行讨论,目前已经清楚认识了通道、上下文以及sync包,通过这三者,完全可以达到完美控制协程运行和目的。
通过go关键字很容易就能启动一个协程,但很好的管理和控制他们的运行却比较难。因此可以根据场景使用以下几种方法。
(1)使用sync.WaitGroup,它用于线程总同步,会等待一组线程集合完成,才会继续向下执行,这对监控所有子协程全部完成的情况特别有用,但要控制某个协程就无能为力了。
(2)使用通道来传递消息,一个协程发送通道信号,另一个协程通过select得到通道消息,这种方式可以满足协程之间的通信,控制协程运行。但如果协程数量达到一定程度,就很难把控了。或者这两个协程还和其他协程也有类似通信,例如A与B,B与C,如果A发信号B退出了,C有可能等不到B的通道信号而被遗忘。
(3)使用上下文来传递消息,上下文是层层传递机制,根节点完全控制了子节点,根节点(父节点)可以根据需要选择自动还是手动结束子节点。而每层节点所在的协程就可以根据信息来决定下一步的操作。
下面来看看这怎么使用上下文控制协程的运行
这里用上下文同时控制两个协程,这两个协程都可以收到cancel()发出的信号,甚至doNothing不结束协程可反复接收取消消息。
package main
import (
"context"
"log"
"os"
"time"
)
var logs *log.Logger
func doClean(ctx context.Context) {
//for 循环每一秒检查一下,判断ctx是否被取消了,如果是就退出
for {
time.Sleep(time.Second * 1)
select {
case <-ctx.Done():
log.Println("doClean接收到Cancel,做好收尾工作后马上退出.")
return
default:
log.Println("doClean每隔一秒观察信号,继续观察...")
}
}
}
func doNothing(ctx context.Context) {
for {
time.Sleep(time.Second * 3)
select {
case <-ctx.Done():
log.Println("doNothing收到Cancel,但不退出.....")
// 退出协程,没有return的话ctx.Done()信号是可以一直接收到的
// return
default:
log.Println("doNothing每隔3秒观察信号,一直运行")
}
}
}
func main() {
logs = log.New(os.Stdout, "", log.Ltime)
//创建一个ctx
ctx, cancel := context.WithCancel(context.Background())
//传递ctx
go doClean(ctx)
go doNothing(ctx)
//主程序阻塞20秒,留给协程来演示
time.Sleep(20 * time.Second)
log.Println("cancel")
//调用cancel: context.WithCancel返回的CancelFunc
cancel()
// 发出cancel命令后,主程序阻塞10秒,在看协程的运行情况
time.Sleep(10 * time.Second)
}
打印结果
2022/04/14 11:12:24 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:25 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:26 doNothing每隔3秒观察信号,一直运行
2022/04/14 11:12:26 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:27 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:28 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:29 doNothing每隔3秒观察信号,一直运行
2022/04/14 11:12:29 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:30 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:31 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:32 doNothing每隔3秒观察信号,一直运行
2022/04/14 11:12:32 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:33 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:34 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:35 doNothing每隔3秒观察信号,一直运行
2022/04/14 11:12:35 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:36 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:37 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:38 doNothing每隔3秒观察信号,一直运行
2022/04/14 11:12:38 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:39 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:40 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:41 doNothing每隔3秒观察信号,一直运行
2022/04/14 11:12:41 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:42 doClean每隔一秒观察信号,继续观察...
2022/04/14 11:12:43 cancel
2022/04/14 11:12:43 doClean接收到Cancel,做好收尾工作后马上退出.
2022/04/14 11:12:44 doNothing收到Cancel,但不退出.....
2022/04/14 11:12:47 doNothing收到Cancel,但不退出.....
2022/04/14 11:12:50 doNothing收到Cancel,但不退出.....
下面代码用上下文嵌套控制3个协程A,B,C。在主程序发出cancel信号后,每个协程都能接收根上下文的Done()信号而退出。
package main
import (
"context"
"fmt"
"time"
)
func A(ctx context.Context) int {
ctx = context.WithValue(ctx, "AFunction", "Great")
go B(ctx)
select {
//监测自己上层的ctx
case <-ctx.Done():
fmt.Println("A Done")
return -1
}
return 1
}
func B(ctx context.Context) int {
fmt.Println("A value in B", ctx.Value("AFunction"))
ctx = context.WithValue(ctx, "BFunction", 999)
go C(ctx)
select {
//监测自己上层的ctx
case <-ctx.Done():
fmt.Println("B Done")
return -2
}
return 2
}
func C(ctx context.Context) int {
fmt.Println("B value in C", ctx.Value("AFunction"))
fmt.Println("B value in C", ctx.Value("BFunction"))
select {
//结束时候做点什么
case <-ctx.Done():
fmt.Println("C Done")
return -3
}
return 3
}
func main() {
// 自动取消(定时取消)
{
timeout := 10 * time.Second
ctx, _ := context.WithTimeout(context.Background(), timeout)
fmt.Println("A执行完成,返回:", A(ctx))
select {
case <-ctx.Done():
fmt.Println("context Done")
break
}
}
time.Sleep(20 * time.Second)
}
结果
A value in B Great
B value in C Great
B value in C 999
A Done
A执行完成,返回: -1
context Done
C Done
B Done
最后看下上下文在http中是怎么传递的
package main
import (
"context"
"net/http"
"time"
)
// ContextMiddle是HTTP服务中间件,统一读取通行cookie并使用ctx传递
func ContextMiddle(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
cookie, _ := r.Cookie("Check")
if cookie != nil {
ctx := context.WithValue(r.Context(), "Check", cookie.Value)
next.ServeHTTP(w, r.WithContext(ctx))
} else {
next.ServeHTTP(w, r)
}
})
}
// 强制设置通行cookie
func CheckHandler(w http.ResponseWriter, r *http.Request) {
expitation := time.Now().Add(24 * time.Hour)
cookie := http.Cookie{Name: "Check", Value: "42", Expires: expitation}
http.SetCookie(w, &cookie)
}
func indexHandler(w http.ResponseWriter, r *http.Request) {
//通过取中间件传过来的context值来判断是否放行通过
if chk := r.Context().Value("Check"); chk == "42" {
w.WriteHeader(http.StatusOK)
w.Write([]byte("Lets go!\n"))
} else {
w.WriteHeader(http.StatusNotFound)
w.Write([]byte("No Pass!"))
}
}
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/", indexHandler)
// 人为设置通行cookie
mux.HandleFunc("/chk", CheckHandler)
ctxMux := ContextMiddle(mux)
http.ListenAndServe(":8080", ctxMux)
}
打开浏览器访问http://localhost:8080/chk,然后访问http://localhost:8080/,由于cookie已经设置,会看到正常通行的结果,否则将会看到无法正常通行时的信息。Context信息的传递主要靠中间件ContextMiddle来进行。
取消信号
context.WithCancel
函数能够从context.Context
中衍生出一个新的子上下文并返回用于取消该上下文的函数。一旦我们执行返回的取消函数,
当前上下文以及它的子上下文都会被取消,所有的Goroutine都会同步收到这一取消信号。
Context子树的取消
我们直接从context.WithCancel
函数的实现来看它到底做了什么:
func WithCancel(parent Context)(ctx Context, cancel CancelFunc){
c := newCancelCtx(parent)
propagateCancel(parent, &c)
return &c, func(){c.cancel(true, Canceled)}
}
context.newCancelCtx
将传入的上下文包装成私有结构体context.cancelCtx
context.propagateCancel
会构建父子上下文之间的关联,当父上下文被取消时,子上下文也会被取消:
func propagateCancel(parent Context, child canceler){
done := parent.Done()
if done == nil{
return // 父上下文不会触发取消信号
}
select{
case <-done:
child.cancel(false, parent.Err()) // 父上下文已经被取消
return
default:
}
if p, ok := parentCancelCtx(parent);ok{
p.mu.Lock()
if p.err != nil{
child.cancel(false, p.err)
}else{
p.children[child] = struct{}{}
}
p.mu.Unlock()
}else{
go func(){
select {
case <-parent.Done():
child.cancel(false, parent.Err())
case <-child.Done()
}
}()
}
}
上述函数总共与父上下文相关的三种不同的情况
- 当
parent.Done()==nil
,也就是parent
不会触发取消事件时,当前函数会直接返回; - 当
child
的继承链包含可以取消的上下文时,会判断parent
是否已经触发了取消信号;
- 如果已经被取消,
child
会立刻被取消 - 如果没有被取消,
child
会被加入parent
的children
列表中,等待parent
释放取消信号
3.当父上下文是开发者自定义的类型,实现了context.Context
接口并在Done()
方法中返回了非空的管道时 - 运行一个新的Goroutine同时监听
parent.Done()
和child.Done()
两个Channel; - 在
parent.Done()
关闭时调用child.cancel
取消子上下文
context.propagateCancel
的作用在parent
和child
之间同步取消和结束的信号,保证在parent
被取消时,
child
也会收到对应的信号,不会出现状态不一致的情况
context.cancelCtx
实现的几个接口方法也没有太多值的分析的地方,该结构体最重要的方法是context.cancelCtx.cancel
该方法会关闭上下文中的Channel并向所有子上下文同步取消信号:
func (c *cancelCtx)cancel(removeFromParent bool, err error){
c.mu.Lock()
if c.err != nil{
c.mu.Unlock()
return
}
c.err = err
if c.done == nil{
c.done == closedchan
}else{
close(c.done)
}
for child := range c.children{
child.cancel(false, err)
}
c.children = nil
c.mu.Unlock()
if removeFromParent{
removeChild(c.Context, c)
}
}
除了context.WithCancel
之外,context
包中的另外两个函数context.WithDeadline
和
context.WithTimeout
也都能创建可以被取消的计时器上下文context.timeCtx
func WithTimeout(parent Context, timeout time.Duration)(Context, CancelFunc){
return WithDeadline(parent, time.Now().Add(timeout))
}
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc){
if cur, ok := parent.Deadline(); ok && cur.Before(d){
return WithCancel(parent)
}
c := &timeCtx{
cancelCtx: newCancelCtx(parent),
deadline: d,
}
propagateCancel(parent, c)
dur := time.Until(d)
if dur <= 0{
c.cancel(true, DeadlineExceeded) // 已经过了截止日期
return c, func(){c.cancel(false, Canceled)}
}
c.mu.Lock()
defer c.mu.Unlock()
if c.err == nil{
c.timer = time.AfterFunc(dur, func(){
c.cancel(true, DeadlineExceeded)
})
}
return c, func(){c.cancel(true, Canceled)}
}
context.WithDeadline
在创建context.timerCtx
的过程中判断了父上下文的截止日期与当前日期,并通过time.AfterFunc
创建定时器,当时间超过了截止日期后会调用context.timeCtx.cancel
同步取消信号
context.timerCtx
内部不仅通过嵌入context.cancelCtx
结构体继承了相关的变量和方法,还通过持有的定时器timer
和截止时间
deadline
实现了定时取消的功能:
type timerCtx struct{
cancelCtx
timer *time.Timer
deadline time.Time
}
func (c *timerCtx)Deadline() (deadline time.Time, ok bool){
return c.deadline, true
}
func (c *timerCtx) cancel(removeFromParent bool, err error){
c.cancelCtx.cancel(false, err)
if removeFromParent{
removeChild(c.cancelCtx.Context, c)
}
c.mu.Lock()
if c.timer != nil{
c.timer.Stop()
c.timer = nil
}
c.mu.Unlock()
}
context.timerCtx.cancel
方法不仅调用了context.cancelCtx.cancel
,还会停止持有的定时器减少不必要的资源浪费
传值方法
context
包中的context.WithValue
能从父上下文中创建一个子上下文,传值的上下文使用context.valueCtx
类型:
func WithValue(parent Context, key, val interface{})Context{
if key == nil{
panic("nil key")
}
if !reflectlite.TypeOf(key).Comparable(){
panic("key is not comparable")
}
return &valueCtx{parent, key, val}
}
context.valueCtx
结构体会将除了Value
之外的Err
、Deadline
等方法代理到父上下文中,它只会响应context.valueCtx.Value
方法,该方法的实现也很简单
type valueCtx struct{
Context
key, val interface{}
}
func (c *valueCtx)value(key interface{}) interface{}{
if c.key == key{
return c.val
}
return c.Context.Value(key)
}
如果context.valueCtx
中存储的键值对与context.valueCtx.Value
方法中传入的参数不匹配,就会从父上下文中查找该键值对应的
值直到某个父上下文中返回nil
或者查找到对应的值