Context
# 定义
一个网络请求Request, 每个Request都需要开启一个goroutine做一些事情,这些goroutine又可能开启其它的goroutine。所以我们需要一种可以跟踪goroutine的方案,才可以达到控制他们的目的,这就是Go语言为我们提供的Context,称之为上下文非常贴切,它就是goroutine的上下文。
func main() {
ctx, cancel := context.WithCancel(context.Background())
go func(ctx context.Context) {
for {
select {
case <- ctx.Done():
fmt.Println("监控退出,停止了。。。")
default:
fmt.Println("goroutine监控中")
time.Sleep(2 * time.Second)
}
}
}(ctx)
time.Sleep(10 * time.Second)
fmt.Println("可以了,通知监控停止")
cancel()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
context.Background() 返回一个空的Context,这个空的Context一般用于整个Context树的根节点。然后我们可以使用context.WithCancel(parent)函数,创造一个可取消的子Context,然后当作参数传给goroutine使用,这样就可以使用这个子Context跟踪这个goroutine。
在gouroutine中,使用select调用<-ctx.Done()判断是否要结束,如果接受到值的话,就可以返回结束goroutine了,如果接收不到,就会继续进行监控。
那么是如何发送结束指令的呢,这就是示例中的cancel函数,它是我们调用context.WithCancel(parent)函数生成子Context的时候返回的,第二个返回值就是这个取消函数,它是CancelFunc类型的。我们调用它就可以发出取消指令,然后我们的监控goroutine就会收到信号,就会返回结束。
# 控制多个goroutine
使用Context控制一个goroutine的例子如上,非常简单,下面我们看看控制多个goroutine的例子。
func main() {
ctx, cancel := context.WithCancel(context.Background())
go watch(ctx, "1")
go watch(ctx, "2")
cancel()
}
func watch(ctx context.Context, name string) {
for {
select {
case <- ctx.Done():
fmt.Println("完成")
return
default:
fmt.Println("12")
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
示例启动了2个监控goroutine进行不断的监控,每一个都使用了Context进行跟踪,当我们使用cancel函数通知取消时,这2个goroutine都会被结束,这就是Context的控制能力,它就像一个控制器一样,按下开关后,所有基于这个Context或者衍生的子Context都会收到通知,这时就可以进行清理操作了,最终释放goroutine,这就优雅的解决了goroutine启动后不可控的问题。
# Context接口
type Context interface {
Deadline() (deadline time.Time, ok bool)
Done() <- chan struct{}
Err() error
Value(key interface{}) interface{}
}
2
3
4
5
6
7
8
9
Deadline方法是获取设置的截止时间的意思,第一个返回截止时间,到了这个时间点,Context会自动发起取消请求;第二个返回ok 等于false时,表示没有设置截止时间,如果需要取消的话,需要调用取消函数进行取消。
Done 方法返回一个只读的chan,类型为struct{},我们在goroutine中,如果该方法返回的chan可以读取,则意味着parent context已经发起了取消请求,我们通过Done方法收到这个信号后,就应该做清理操作,然后退出goroutine, 释放资源。
Err方法返回取消的错误原因,因为什么Context被取消。
Value方法获取该Context上绑定的值,是一个键值对,所以要通过一个Key才可以获取对应的值,这个值一般是线程安全的。
以上4个方法常用的就是Done了,如果Context取消的时候,我们就可以得到一个关闭的chan,关闭的chan是可以读取的,所以只要可以读取的时候,就意味着收到Context取消的信号了,以下是这个方法的经典用法。
func Stream(ctx context.Context, out chan<- Value) error {
for {
v, err := DoSomething(ctx)
if err != nil {
return err
}
select {
case <- ctx.Done():
return ctx.Err()
case out <-v
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
Context接口并不需要我们实现,Go内置已经帮我们实现了2个,我们代码最开始都是以这两个内置的作为最顶层的partent context,衍生出更多的子Context。
var (
background = new(emptyCtx)
todo = new(emptyCtx)
)
func Background() Context {
return background
}
func TODO() Context {
return todo
}
2
3
4
5
6
7
8
9
10
11
12
一个是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
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
这就是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, value interface{}) Context
2
3
4
5
6
7
这4个with函数,接收的都有一个partent参数,就是父Context,我们要基于这个父Context创建出子Context的意思,这个方式可以理解为子Context对父Context的继承,也可以理解为基于父Context的衍生。
通过这些函数,就创建了一颗Context树,树的每个节点都可以有任意多个子节点,节点层级可以有任意多个。
WithCancel函数,传递一个父Context作为参数,返回子Context,以及一个取消函数用于取消Context。
WithDeadline函数,和WithCancel差不多,它会多传递一个截止时间参数,意味着到了这个时间点,会自动取消Context,当然我们也可以不等到这个时候,可以提前通过取消函数进行取消。
WithTimeout和WithDeadine基本一样,这个表示是表示超时自动取消,是多少时间后自动取消Context的意思。
WithValue函数和取消Context无关,它是为了生成一个绑定了一个键值对数据的Context,这个绑定的数据可以通过Context.Value 方法访问到。
前三个函数都返回一个取消函数CancelFunc, 这是一个函数类型,它的定义非常简单。
type CancelFunc func()
这就是取消函数的类型,该函数可以取消一个Context,以及这个节点Context下所有的Context。
# WithValue传递元数据
通过Context 我们也可以传递一些必须的元数据,这些数据会附加在Context上以供使用。
var key string="name"
func main() {
ctx, cancel := context.WithCancel(context.Background())
valueCtx := context.WithValue(ctx, key, "123")
go watch(valueCtx)
cancel()
}
func watch(ctx context.Context) {
for {
select {
case <- ctx.Done();
fmt.Println(ctx.Value(key))
return
default:
fmt.Println(ctx.Value(key))
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Context使用原则
- 1.不要把Context放在结构体中,要以参数的方式传递
- 2.以Context作为参数的函数方法,应该把Context作为第一个参数,放在第一位。
- 3.给一个函数方法传递Context的时候,不要传递nil,如果不知道传递什么,就使用context.TODO
- 4.Context的Value相关方法应该传递必须的数据,不要什么数据都使用这个传递
- 5.Context是线程安全的,可以放心的在多个goroutine中传递
# 源码学习
package context
import (
"errors"
"internal/reflectlite"
"sync"
"sync/atomic"
"time"
)
type Context interface {
Deadline() (deadline time.Time, ok bool)
Done() <-chan struct{}
Err() error
Value(key any) any
}
var Canceled = errors.New("context canceled")
var DeadlineExceeded error = deadlineExceededError{}
type deadlineExceededError struct{}
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
}
var (
background = new(emptyCtx)
todo = new(emptyCtx)
)
func Background() Context {
return background
}
func TODO() Context {
return todo
}
type cancelCtx struct {
Context
mu sync.Mutex
done atomic.Value
children map[canceler]struct{}
err error
}
type CancelFunc func()
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
if parent == nil {
panic("cannot create context from nil parent")
}
c := newCancelCtx(parent)
}
func newCancelCtx(parent Context) cancelCtx {
return cancelCtx{Context: parent}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75