Golang之context

LinkinStar · · 1101 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

前言

当我们使用一些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.

用法

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

传递信息

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如何实现呢?

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

// 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的子节点。

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来自:

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因为有了锁,所以是并发安全的。

取消

// 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

type valueCtx struct {
    Context
    key, val interface{}
}

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

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放进去。

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开发的时候非常实用。

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参数

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的使用,还可以学到这样设计一个系统的优点,如果以后自己在设计一些框架和系统的时候可以有更多的想法。


有疑问加站长微信联系(非本文作者)

本文来自:简书

感谢作者:LinkinStar

查看原文:Golang之context

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

1101 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传