Go的context的问题

2017-05-29

最近被由context引发的一个bug坑得不轻,所以反思一下Go的context的问题。

context是隐式的约束,没有检测

如果我们写一个函数,比如:

func f(a int, b []byte) {
}

我们知道它需要哪些参数,编译器是会帮我做检查的,当我调用

f(3, "sdfsdf")

它就会报错。

可是如果是context,就变成了一种隐式的约束,编译器不会帮我们做检查,比如:

func f(ctx context.Context) {
    a := ctx.Value("a").(int)
    b := ctx.Value("b").([]byte)
}

Value函数并没有任何保证,编译器不会检查传进来的参数是否是合理。然而f在什么样的上下文里面被调用是不确定的,因此检测被移到了运行时来做。

现在的函数f有一个隐式的约束,它需要从context里面传a和b两个参数,这些信息,在函数f的签名里面都没法体现。 如果我看一个函数,看它的签名没用,还得去读它的实现,这不是扯淡么!

context的锁争用

context是一层一层往下传的,如果全局都是使用同一个传递下来的context,会出现一个问题:锁争用。

select {
    case <-context.Done():
}

大家都在同一个对象上面调用的Done函数,channel操作最终会加锁。这个是在etcd项目里面发现的一个问题,他们改了我们也跟着改了。在起goroutine的时候,一般不要用原来的context了,而是新建一个context,原始的context作为父context。这样不同goroutine就不会抢同一个锁。

一般是用的context.WitCancel()这个函数:

go func() {
    ctx, cancel = context.WithCancel(ctx)
    doSomething(ctx)
    cancel()
}

调用WithCancel的时候,会得到一个新的子context,以及一个cancel函数。子ctx会在父context的Done函数收到信号,或者cancel被调用的情况下收到Done信号。

cancel是需要调用,它使得context释放相应的资源。开头提到的bug,就是这个地方被坑到了:这样写代码之后其实有一个假定的约束,即doSomething操作是一个同步的,当它返回以后,相应的context就已经结束了。

然后,我们的代码在doSomething里面函数调了很深之后(a调b,b调c,c调d),里面有一个开goroutine异步做的操作,于是就傻逼了。那个异步的操作还没完成,就被cancel掉了。

但是这个问题非常难查,为什么?因为单独看两个地方的代码片断,都没有看出任何问题。上面那段代码写的没问题呀,只要doSomething是一个同步操作就行。而看doSomething的逻辑也没问题,它调了其它函数,其它函数继续调更深的函数,只是到了那里,并没有任何关于禁止异步操作的约束说明。

不要将任何context保存为成员变量

context的标准用法就是每次都产生一个,然后一层一层往下传。注意,禁止将context捕获了存储下来。不要将任何context保存为成员变量,不要重用它们。

比如,我要做一个sender对象,它有一个Send方法。那么我不能在new的时候把ctx保存下来,在Send的时候使用:

func NewSender(ctx context.Context) *sender {
    return &sender {
        ctx: ctx,
    }
}
func(s *sender) Send() {
    grpc.XXX(s.ctx)
}

如果调用某个库它需要传一个context,你应该给它当时的上下文,如果没有,可以传context.Background(),但是不要像上面那样,创建对象的时候把context保存下来,到对象的方法调用的时候使用。

正确的使用姿势不应该看到context被保存到任何成员变量里面。

context本质上是动态作用域

上面说到不要将context保存。让我们看一看问题的本质:

obj = new Object(ctx)
obj.method(ctx)

请问这是同一个上下文么? No! 一个时创建时的上下文,一个是运行时的上下文。其实正确来写,它们是这样子的:

obj = new Object(ctx1)
obj.method(ctx2)

那么把ctx1保存下来,给到ctx2用,当然不对。

被坑几次之后会觉得context很难用。我想了一下,其实这个问题跟动态作用域很类似。现代主流编程语言里面,没有任何一个采用动态作用域的,而人们大多习惯了词法作用域,所以思维上很难接受。

正好说一下动态作用域:

func f() {
    a := 3
    func g() int {
        return a
    }
}

采用词法作用域的语言,无论在哪里调用g(),返回的结果都是3。而采用动态作用域的语言,行为完全无法推断:

a := 7
g() // 这里返回的是7,a的值是看运行时绑定的,而不是声明时
a := 3
g() // 这里返回的是3

当你看到函数需要的参数是一个context,可以context是在每次运行时都不同了,仅仅看声明并没有什么信息,是不是很像动态作用域?

golangcontext