golang并发编程实战（《Go 语言并发之道》读书笔记（六））

今天这篇笔记我们来学习一下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