什么是context
context是golang在1.7版本的时候引入的标准库,从名字也知道是"上下文",不过准确的说应该是goroutine的上下文,它包含了goroutine的运行状态、环境等信息。
context主要是用来在goroutine之间传递上下文信息,包括:取消信号、超时时间、截止时间等等。
为什么会有context
我们在context之前一般会使用WaitGroup来协调多个协程,但是WaitGroup要求的是多个协程必须都完成,那么才算完成,否则就会一直阻塞。
package main
import (
"fmt"
"sync"
"time"
)
func main() {
wg := new(sync.WaitGroup)
wg.Add(3)
go func() {
time.Sleep(time.Second)
fmt.Println("任务1完成")
wg.Done()
}()
go func() {
time.Sleep(time.Second * 3)
fmt.Println("任务2完成")
wg.Done()
}()
go func() {
time.Sleep(time.Second * 2)
fmt.Println("任务3完成")
wg.Done()
}()
wg.Wait()
fmt.Println("任务都完成了,收工")
/*
任务1完成
任务3完成
任务2完成
任务都完成了,收工
*/
}
我们看到只有当3个任务都完成才算完成,否则wg.Wait()就会一直阻塞在那里,所以WaitGroup就是控制一组goroutine。但是实际上,我们会碰到这样一种场景,我们需要主动地通知某个goroutine让其退出。比如有一个goroutine一直在监视某个资源的变化,但是现在不需要了,于是我们就需要主动地通知它,让其退出,否则很容易造成内存泄露。
但是现在问题来了,我们知道当一个goroutine启动之后,我们是无法控制它的,大部分情况是等待它自己结束。但如果是一个不会自己结束的一个goroutine呢?比如:我需要一个goroutine不断监视某个目录,如果有新文件,那么就进行相应的逻辑,但是只需要监视三天,三天之后就不需要监视这个目录了,那么我们就应该让这个goroutine停掉。目前可以使用chan + select:
package main
import (
"fmt"
"time"
)
func main() {
go func() {
for {
select {
//其他逻辑
//这里假设是3s吧,3s后,这个goroutine就退出了
case <-time.After(time.Second * 3):
fmt.Println("3s已到,这个goroutine已经退出")
return
}
}
}()
for {}
/*
3s已到,这个goroutine已经退出
*/
}
再比如说,可以在满足指定的条件之后,让goroutine退出。
package main
import (
"fmt"
)
func main() {
quitCh := make(chan int)
go func(quitCh chan int) {
for {
select {
//其他逻辑
//我们看到,如果我们想让这个goroutine退出,那么就给quitCh这个channel发送一个值即可。
case <-quitCh:
fmt.Println("这个goroutine已经退出")
return
}
}
}(quitCh)
fmt.Println("程序执行中······")
//退出goroutine
quitCh <- 0
for {}
/*
程序执行中······
这个goroutine已经退出
*/
}
我们看到这种chan+select是一种比较优雅地结束一个goroutine的方式,但是它有一个缺点,如果有很多的goroutine的结束都需要控制该怎么办?另外这些goroutine又衍生了其他的goroutine怎么办?即使我们定义了很多chan也很难解决这些问题,因为goroutine的关系链就导致了这种场景十分复杂。
所以我们才需要有context。
初识context
我们上面说的那种场景是真实存在的,比如一个网络请求Request,每个Request都需要开启一个goroutine做一些事情,而这些goroutine又需要开启其他的goroutine,所以我们就需要一种可以跟踪goroutine的方案,才可以达到控制它们的目的。context包就是为了解决上面的问题而开发的:使用context可以在一组goroutine之间传递共享的值、取消信号、deadline······。
总结一下就是:在go里面我们不能直接杀死协程,协程的关闭一般会使用channel+select
的方式。但是在某些场景下,例如处理一个请求衍生了许多协程,这些协程之间是互联的:需要共享一些全局变量、有共同的deadline等等,而且可以同时被关闭再用 channel+select
就会比较麻烦,这时就可以通过 context 来实现。
一句话:context 用来解决goroutine之间退出通知、 元数据传递的功能。
package main
import (
"context"
"fmt"
"time"
)
func goroutine1(ctx context.Context){
for {
select {
case <-ctx.Done():
fmt.Println("goroutine1完成任务,退出")
return
default:
fmt.Println("goroutine1工作中")
time.Sleep(time.Second * 3)
}
}
}
func goroutine2(ctx context.Context){
for {
select {
case <-ctx.Done():
fmt.Println("goroutine2完成任务,退出")
return
default:
fmt.Println("goroutine2工作中")
time.Sleep(time.Second * 2)
}
}
}
func goroutine3(ctx context.Context){
for {
select {
case <-ctx.Done():
fmt.Println("goroutine3完成任务,退出")
return
default:
fmt.Println("goroutine3工作中")
time.Sleep(time.Second * 4)
}
}
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
go goroutine1(ctx)
go goroutine2(ctx)
go goroutine3(ctx)
time.Sleep(time.Second * 10)
fmt.Println("时间到,通知所有goroutine退出")
cancel()
/*
goroutine1工作中
goroutine3工作中
goroutine2工作中
goroutine2工作中
goroutine1工作中
goroutine3工作中
goroutine2工作中
goroutine1工作中
goroutine2工作中
goroutine3工作中
goroutine2工作中
goroutine1工作中
时间到,通知所有goroutine退出
*/
}
仔细观察代码的话,应该不难理解。ctx.Done()是一个channel,当我们调用cancel()的时候,是可以从里面读取数据的。但是我们发现,所有的goroutine都退出了,这就是Context的一个特点,会对每一个goroutine都进行跟踪,当我们使用cancel函数通知取消的时候,Context跟踪的goroutine都会被结束。这就是Context的控制能力,它就像一个控制器一样,按下开关后,所有基于这个Context或者衍生的子Context都会收到通知,这时就可以进行清理操作了,最终释放goroutine,这就优雅的解决了goroutine启动后不可控的问题。
下面我们再来看看context.WithCancel(context.Background())
这一句是干嘛的,首先我们知道肯定返回了一个Context对象和一个函数,context.Background()
返回一个空的Context,这个空的Context一般用于整个Context树的根节点。然后我们使用context.WithCancel(parent)
函数,创建一个可取消的子Context,然后当作参数传给goroutine使用,这样就可以使用这个子Context跟踪这个goroutine。
Context接口
Context是一个接口,里面定义了四个方法,并且它们都是幂等的,也就是说连续调用多次得到的结果都是相同的。
type Context interface {
//返回一个截止时间和一个布尔值。
//到达指定的时间点,Context会自动发起取消请求,此时ok是true。
//如果ok==false,那么表示没有设置截止时间,如果需要取消的话,就需要手动调用取消函数进行取消
Deadline() (deadline time.Time, ok bool)
//返回一个只读的channel,类型为struct{},我们在goroutine中,如果该方法返回的channel可以读取,则意味着parent context已经发起了取消请求。
//然后通过Done方法收到这个信号之后,可以做一些清理操作,然后退出goroutine,释放资源。
Done() <-chan struct{}
//返回一个错误原因,因为什么导致Context被取消
Err() error
//获取该Context上绑定的值,是一个键值对,所以要通过一个Key才可以获取对应的值,这个值一般是线程安全的。
Value(key interface{}) interface{}
}
以上四个方法中常用的就是Done
了,如果Context取消的时候,我们就可以得到一个关闭的chan,关闭的chan是可以读取的,所以只要可以读取的时候,就意味着收到Context取消的信号了,所以Context监视的所有goroutine才能都接收到信号。以下是这个方法的经典用法:
package main
import (
"context"
"fmt"
"time"
)
func goroutine1(ctx context.Context){
for {
select {
case <-ctx.Done():
//等待退出的信号
fmt.Println("收到取消通知,我要退出啦,使命已经结束")
return
default:
//什么也不做,为了select不阻塞
}
//todo: 努力工作
func(){
time.Sleep(time.Second * 3)
fmt.Println("bob,别傻愣着")
}()
}
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
go goroutine1(ctx)
time.Sleep(time.Second * 9)
fmt.Println("结束啦~~~~,通知协程退出")
cancel()
//可能要忙其他的事情
for {}
/*
bob,别傻愣着
bob,别傻愣着
结束啦~~~~,通知协程退出
bob,别傻愣着
收到取消通知,我要退出啦,使命已经结束
*/
}
Context的接口不需要我们实现,Go内置了两个。
var (
background = new(emptyCtx)
todo = new(emptyCtx)
)
func Background() Context {
return background
}
func TODO() Context {
return todo
}
一个是Background
,主要用于main函数、初始化以及测试代码中,作为Context这个树结构的最顶层的Context,也就是根Context。一个是TODO
,它目前还不知道具体的使用场景,如果我们不知道该使用什么Context的时候,可以使用这个。不过从定义上来看的话,这两个是没有任何区别的,真的只有名字不一样而已。
他们两个本质上都是emptyCtx结构体类型,是一个不可取消,没有设置截止时间,没有携带任何值的Context。
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
}
这就是emptyCtx
实现Context接口的方法,可以看到,这些方法什么都没做,返回的都是nil或者零值。
context的继承衍生
有了如上的根Context,那么如何衍生更多的子Context的呢?这就要靠context包为我们提供的With
系列的函数了。
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函数,都接收了一个parent参数,也就是父Context,我们要基于这个父Context创建出子Context的意思,这种方式可以理解为子Context对父Context的继承,也可以理解为基于父Context的衍生。通过这些函数,就创建了一颗Context树,树的节点都可以有任意多个子节点,节点层级可以有任意多个。
WithCancel
函数,传递一个父Context作为参数,返回子Context,以及一个取消函数用来取消Context。 WithDeadline
函数,和WithCancel
差不多,它会多传递一个截止时间参数,意味着到了这个时间点,会自动取消Context,当然我们也可以不等到这个时候,可以提前通过取消函数进行取消。而WithTimeout
和WithDeadline
基本上一样,这个表示是超时自动取消,是多少时间后自动取消Context的意思。可以把前面的WithDeadline
理解为到达指定的时间点取消,WithTimeout
理解为达到指定的时间间隔取消。
WithValue
函数和取消Context无关,它是为了生成一个绑定一个键值对数据
的Context,这个绑定的数据可以通过Context.Value
方法访问到,后面我们会专门讲。
大家可能留意到,前三个函数都返回一个取消函数CancelFunc
,这是一个函数类型,它的定义非常简单。
type CancelFunc func()
这就是取消函数的类型,该函数可以取消一个Context,以及这个节点Context下所有的所有的Context,不管有多少层级。
WithValue传递元数据
通过Context我们也可以传递一些必须的元数据,这些数据会附加在Context上以供使用。
package main
import (
"context"
"fmt"
"time"
)
func goroutine1(ctx context.Context){
for {
select {
case <-ctx.Done():
//等待退出的信号
fmt.Println("收到取消通知,我要退出啦,使命已经结束")
fmt.Printf("拿到传入的值:%s", ctx.Value("name"))
return
default:
//什么也不做,为了select不阻塞
}
//todo: 努力工作
func(){
time.Sleep(time.Second * 3)
fmt.Println("bob,别傻愣着")
}()
}
}
func main() {
ctx, cancel := context.WithCancel(context.TODO())
//这里是基于返回的ctx进行创建的,接收三个参数:Context,interface{},interface{}
valueCtx := context.WithValue(ctx, "name", "satori")
//传入的不再是ctx,而是基于ctx新创建的valueCtx
go goroutine1(valueCtx)
time.Sleep(time.Second * 9)
fmt.Println("结束啦~~~~,通知协程退出")
//调用cancel()的时候,不光是<-ctx.Done()可以获取数据,<-valueCtx.Done()一样可以获取数据
cancel()
//可能要忙其他的事情
for {}
/*
bob,别傻愣着
bob,别傻愣着
结束啦~~~~,通知协程退出
bob,别傻愣着
收到取消通知,我要退出啦,使命已经结束
拿到传入的值:satori
*/
}
我们可以使用context.WithValue
方法附加一对K-V的键值对,这里Key必须是等价性的,也就是具有可比性;Value值要是线程安全的。这样我们就生成了一个新的Context,这个新的Context带有这个键值对,在使用的时候,可以通过Value
方法读取ctx.Value(key)
。记住,使用WithValue传值,一般是必须的值,不要什么值都传递
context使用原则
1.Do not store Contexts inside a struct type; instead, pass a Context explicitly to each function that needs it. The Context should be the first parameter, typically named ctx.
2.Do not pass a nil Context, even if a function permits it. Pass context.TODO if you are unsure about which Context to use.
3.Use context Values only for request-scoped data that transits processes and APIs, not for passing optional parameters to functions.
4.The same Context may be passed to functions running in different goroutines; Contexts ar safe for simultaneous use by multiple goroutines.
1.不要将 Context 塞到结构体里。直接将 Context 类型作为函数的第一个参数,而且一般都命名为 ctx。
2.不要向函数传入一个 nil 的 context,如果你实在不知道传什么,标准库给你准备好了一个 context:todo。
3.不要把本应该作为函数参数的类型塞到 context 中,context 存储的应该是一些共同的数据。例如:登陆的 session、cookie 等。
4.同一个 context 可能会被传递到多个 goroutine,别担心,context 是并发安全的。
参考
码农桃花源:https://mp.weixin.qq.com/s/GpVy1eB5Cz_t-dhVC6BJNw
飞雪无情:https://www.flysnow.org/2017/04/29/go-in-action-go-runner.html
原文地址:https://www.cnblogs.com/traditional/p/12232156.html