今天这篇笔记我们来学习一下context包
context包的一个应用场景是可以通过它控制goroutine的取消，超时等。
我们先来看一个取消的例子
context.WithCancel
func doSomething(ctx context.Context) {
ctx, cancelctx := context.WithCancel(ctx)
printCh := make(chan int)
go doAnother(ctx, printCh)
for i := 0; i < 3; i++ {
printCh <- i
}
cancelctx()
fmt.Println("do something finished")
}
func doAnother(ctx context.Context, printCh chan int) {
for {
select {
case <-ctx.Done():
if err := ctx.Err(); err != nil {
fmt.Printf("do Another with error, %s \n", err)
}
fmt.Println("do Another finished")
return
case data := <-printCh:
fmt.Printf("receive %d \n", data)
}
}
}
我们在doSomething方法中加了一个可以取消的Context， 然后定义了一个channel, 往channel里面放入3个数，另外启动一个goroutine doAnother 来接收它, 在完成放入数据后我们调用了取消方法， 通知doAnother 结束掉。 这样程序就达到一个goroutine通知另外一个goroutine的效果， 程序运行结果如下
receive 0
receive 1
receive 2
do Another with error, context canceled
do Another finished
do something finished
通过打印的输出我们可以看到doAnother是通过canneled来结束的。
如果我们再加一个goroutine，也能够通过context来取消。 这里比较简单不贴代码了。
context.WithTimeout
如果只是单纯的通知另外一个goroutine，直接通过close channel也可以做到了， Context还可以通过WithTimeout设定超时时间来限定程序运行多久，我们简单改造一下上面的代码
func doSomething(ctx context.Context) {
ctx, cancelctx := context.WithTimeout(ctx, 1500*time.Millisecond)
defer cancelctx()
printCh := make(chan int)
go doAnother(ctx, printCh)
outer:
for i := 0; i < 3; i++ {
select {
case printCh <- i:
time.Sleep(1 * time.Second)
case <-ctx.Done():
break outer
}
}
cancelctx()
fmt.Println("do something finished")
我们把doSomething改造了一下， 通过context.WithTimeout(ctx, 1500*time.Millisecond)将context 改成运行1.5秒就退出, doAnother 保持不变， 然后发送的时候，发送一个就sleep 1秒。 运行效果如下
receive 0
receive 1
do Another with error, context deadline exceeded
do Another finished
do something finished
我们可以看到只发送了两个数，就退出了，退出的原因是exceeded. 这样就达到了控制goroutine运行时间的效果。
通过context.WithDeadline 也可以达到和WithTimeout一样的效果，只是一个是按时间点来停，一个是按时间段来停， 示例代码如下
deadLineTime := time.Now().Add(1500 * time.Millisecond)
ctx, cancelctx := context.WithDeadline(ctx, deadLineTime)
context.WithValue
context还有个用途是用来记录和传递value, 比如我们可以向别的goroutine传递UserID，RequestID等要跟踪的变量信息。 还是通过示例代码来说明
func main() {
var ctx = context.Background()
key := 1
ctx = context.WithValue(ctx, key, "someValue")
doSomething(ctx)
}
func doSomething(ctx context.Context) {
fmt.Printf("Doing something! %s \n", ctx.Value(1))
}
输出结果很简单就是"Doing something! someValue" 这个someValue就是通过Context传递给doSomething方法里面的。 如果ctx.Value的key不存在，也不会报错，会返回nil.
上面key的写法，Visual Studio Code会提示”should not use built-in type int as key for value; define your own type to avoid collisions“
就是说这个key可能冲突，比如你的程序用String "userID", 别人也用String ”userID“, 你取的时候取到别人用的了，那样就给程序带来隐患， 我们需要自定义key, 如下代码示例
type ctxKey int
const (
ctxUserKey ctxKey = iota
ctxAuthToken
)
func main() {
var ctx = context.Background()
ctx = context.WithValue(ctx, ctxUserKey, "someValue")
doSomething(ctx)
}
func doSomething(ctx context.Context) {
fmt.Printf("Doing something! %s \n", ctx.Value(ctxUserKey))
}
我们定义了常量ctxUserKey， 它是ctxKey类型，ctxUserKey它的实际值是0， 在取值和赋值的时候我们同意用ctxUserKey， 这样就能很清楚明白的拿到它的value. 如果我们用ctx.Value(0)是拿不到值的。
最后
作者在书中说context包的包一直存在争议，为什么呢？ 因为它可以放入任意类型，这样就让有些偷懒的程序员把它当垃圾桶， 程序运行需要的参数也用它来传递，这样它就被赋予了太多它不应该的功能。 那么我们需要遵守一定的规则来使用它，作者给出了建议
1, 数据应该通过进程或API边界， 这句话感觉是翻译问题，不是特别清楚，我感觉作者的意思是通过明确的参数来传递数据，而不是context
2，数据应该是不可变的。 意思就是只WithValue一次，不要去修改它
3，数据应该趋向简单类型， 保持简单很重要
4，数据应该是数据，而不是类型与方法， 也是保持简单
5，数据应该用于装饰操作，而不是驱动操作。意思就是你不要通过context里面的内容来决定你的代码逻辑。
作者最后说context提供的取消功能非常有用， 就是WithValue不要滥用。这一章感觉翻译的不好，读起来很晦涩，我还是看了另外一篇文章搞明白的。 贴出链接在此https://www.digitalocean.com/community/tutorials/how-to-use-contexts-in-go
文章评论