当我们使用一些golang框架的时候,总能在框架中发现有个叫做context的东西。如果你之前了解过java的spring,那么你肯定也听说过其中有个牛逼的ApplicationContext。Context这个东西好像随时随地都在出现,在golang中也是非常重要的存在。今天我们就来看看这个神奇的Context。

定义

  • 首先我们要知道什么是context?

很多人把它翻译成上下文,其实这个是一个很难描述很定义的东西,对于这种东西,我习惯用功能去定义它。
我的定义是:context是用于在多个goroutines之间传递信息的媒介。
官方定义:At Google, we developed a context package that makes it easy to pass request-scoped values, cancelation signals, and deadlines across API boundaries to all the goroutines involved in handling a request.

用法

同样的我们先来看看它的一些基本用法,大致了解它的使用。

传递信息

1
2
3
4
5
6
func main() {
ctx := context.Background()
ctx = context.WithValue(ctx, "xxx", "123")
value := ctx.Value("xxx")
fmt.Println(value)
}

其实传递消息很简单,只需要通过context.WithValue方法设置,key-value然后通过ctx.Value方法取值就可以了。

暂时不用关心context.Background()只要知道context有传递值的功能就可以了。

关闭goroutine

在我们写golang的时候goroutine是一个非常常用的东西,我们经常会开一个goroutine去处理对应的任务,特别是一些循环一直处理的情况,这些goroutine需要知道自己什么时候要停止。
我们常见的解决方案是使用一个channel去接收一个关闭的信号,收到信号之后关闭,或者说,需要一个标识符,每个goroutine去判断这个标识符的变更从而得知什么时候关闭。
那么用context如何实现呢?

1
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
func main() {
ctx, _ := context.WithTimeout(context.Background(), time.Second * 3)
go func() {
go1(ctx)
}()
go func() {
go2(ctx)
}()
time.Sleep(time.Second * 5)
}

func go1(ctx context.Context) {
for {
fmt.Println("1 正在工作")
select {
case <-ctx.Done():
fmt.Println("1 停止工作")
return
case <-time.After(time.Second):
}
}
}

func go2(ctx context.Context) {
for {
fmt.Println("2 正在工作")
select {
case <-ctx.Done():
fmt.Println("2 停止工作")
return
case <-time.After(time.Second):
}
}
}

通过context.WithTimeout我们创建了一个3秒后自动取消的context;
所有工作goroutine监听ctx.Done()的信号;
收到信号就证明需要取消任务;

其实使用起来比较简单,让我们来看看内部的原理。

源码解析

创建

context.TODO()

这个就是创建一个占位用的context,可能在写程序的过程中还不能确定后期这个context的作用,所以暂时用这个占位

context.Background()

这个是最大的context,也就是根context,这里就有必要说一下context的整个构成了,context其实构成的是一棵树,Background为根节点,每次创建一个新的context就是创建了一个新的节点加入这棵树。

context.WithTimeout()

比如这个方法,创建一个自动过期的context

1
2
3
4
5
6
7
8
9
10
11
12
13
// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
//
// Canceling this context releases resources associated with it, so code should
// call cancel as soon as the operations running in this Context complete:
//
// func slowOperationWithTimeout(ctx context.Context) (Result, error) {
// ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
// defer cancel() // releases resources if slowOperation completes before timeout elapses
// return slowOperation(ctx)
// }
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
return WithDeadline(parent, time.Now().Add(timeout))
}

可以看到需要传入一个parent,和过期时间,新创建的context就是parent的子节点。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
if cur, ok := parent.Deadline(); ok && cur.Before(d) {
// The current deadline is already sooner than the new one.
return WithCancel(parent)
}
c := &timerCtx{
cancelCtx: newCancelCtx(parent),
deadline: d,
}
propagateCancel(parent, c)
dur := time.Until(d)
if dur <= 0 {
c.cancel(true, DeadlineExceeded) // deadline has already passed
return c, func() { c.cancel(true, 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) }
}

注意其中cancelCtx: newCancelCtx(parent),其实是创建了一个可以取消的ctx,然后利用time.AfterFunc来实现定时自动过期。

还有一个细节
c.mu.Lock()
defer c.mu.Unlock()
这个mu来自:

1
2
3
4
5
6
7
8
type cancelCtx struct {
Context

mu sync.Mutex // protects following fields
done chan struct{} // created lazily, closed by first cancel call
children map[canceler]struct{} // set to nil by the first cancel call
err error // set to non-nil by the first cancel call
}

这个context因为有了锁,所以是并发安全的。

取消

1
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
// cancel closes c.done, cancels each of c's children, and, if
// removeFromParent is true, removes c from its parent's children.
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
if err == nil {
panic("context: internal error: missing cancel error")
}
c.mu.Lock()
if c.err != nil {
c.mu.Unlock()
return // already canceled
}
c.err = err
if c.done == nil {
c.done = closedchan
} else {
close(c.done)
}
for child := range c.children {
// NOTE: acquiring the child's lock while holding parent's lock.
child.cancel(false, err)
}
c.children = nil
c.mu.Unlock()

if removeFromParent {
removeChild(c.Context, c)
}
}

当达到过期时间或者调用cancelFunc的时候就会触发context的取消,然后看到上面的源码你就明白了,取消的时候有一个三个操作:

  1. c.mu.Lock() 加锁保证安全
  2. close(c.done) 将done信道关闭,从而所有在观察done信道的goroutine都知道要关闭了
  3. for child := range c.children 循环每个子节点,关闭每个子节点。我们知道context的结构是树状的,所以同时我们要注意父节点如果关闭会关闭子节点的context。

WithValue和Value

1
2
3
4
type valueCtx struct {
Context
key, val interface{}
}

首先valueCtx的结构如上所示,包含一个Context和key-val

1
2
3
4
5
6
7
8
9
func WithValue(parent Context, key, val interface{}) Context {
if key == nil {
panic("nil key")
}
if !reflect.TypeOf(key).Comparable() {
panic("key is not comparable")
}
return &valueCtx{parent, key, val}
}

其实这个方法很简单,就是创建了一个parent的拷贝,并且将对应的key和val放进去。

1
2
3
4
5
6
func (c *valueCtx) Value(key interface{}) interface{} {
if c.key == key {
return c.val
}
return c.Context.Value(key)
}

Value方法就更简单了,就是判断当前key是否匹配,如果不匹配就去子节点寻找。

案例

最后我们来看看在实际的使用过程中,我们在哪里使用到了context,我举两个实际中常用的框架gin和etcd

gin

gin是一个web框架,在web开发的时候非常实用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func main() {
router := gin.Default()

router.POST("/post", func(c *gin.Context) {

id := c.Query("id")
page := c.DefaultQuery("page", "0")
name := c.PostForm("name")
message := c.PostForm("message")

fmt.Printf("id: %s; page: %s; name: %s; message: %s", id, page, name, message)
})
router.Run(":8080")
}

其实很多web框架都有Context,他们都自己封装了一个Context,利用这个Context可以做到一个request-scope中的参数传递和返回,还有很多操作通通都可以用Context来完成。

etcd

如果你没有了解过etcd你就可以把它想象成redis,它其实是一个分布式的k-v数据存储
我们在使用etcd进行操作(put或del等)的时候,需要传入context参数

1
2
3
4
5
6
7
8
timeoutCtx, cancel := context.WithTimeout(context.Background(), 2 * time.Second)
defer cancel()
putResponse, err := client.Put(timeoutCtx, "aaa", "xxx")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(putResponse.Header.String())

这里传入的context是一个超时自动取消的context,也就是说,当put操作超过两秒后还没有执行成功的话,context就会自动done,同时这个操作也将被取消。

因为我们在使用etcd的时候,如果当前网络出现异常,无法连接到节点,或者是节点数量不足的时候,都会出现操作被hang住,如果没有定时取消的机制,或者手动取消,那么当前goroutine会被一直占用。所以就利用context来完成这个操作。

总结

  • context在web开发中,你可以类比java中的ThreadLocal,利用它来完成一个request-scope中参数的传递
  • context可以用于多个goroutine之间的参数传递
  • context还可以作为完成信号的通知
  • context并发安全

其实,我们不仅要学到context的使用,还可以学到这样设计一个系统的优点,如果以后自己在设计一些框架和系统的时候可以有更多的想法。