Iris中间件使用

Context 使用原则 和 技巧

• 不要把Context放在结构体中，要以参数的方式传递，parent Context一般为Background
• 应该要把Context作为第一个参数传递给入口请求和出口请求链路上的每一个函数，放在第一位，变量名建议都统一，如ctx。
• 给一个函数方法传递Context的时候，不要传递nil，否则在tarce追踪的时候，就会断了连接
• Context的Value相关方法应该传递必须的数据，不要什么数据都使用这个传递
• Context是线程安全的，可以放心的在多个goroutine中传递
• 可以把一个 Context 对象传递给任意个数的 gorotuine，对它执行 取消 操作时，所有 goroutine 都会接收到取消信号。

Context的常用方法实例

1. 调用Context Done方法取消

   func Stream(ctx context.Context, out chan<- Value) error {
   
       for {
           v, err := DoSomething(ctx)
   
           if err != nil {
               return err
           }
           select {
           case <-ctx.Done():
   
               return ctx.Err()
           case out <- v:
           }
       }
   }
   

    

2.  通过 context.WithValue 来传值

   func main() {
       ctx, cancel := context.WithCancel(context.Background())
   
       valueCtx := context.WithValue(ctx, key, "add value")
   
       go watch(valueCtx)
       time.Sleep(10 * time.Second)
       cancel()
   
       time.Sleep(5 * time.Second)
   }
   
   func watch(ctx context.Context) {
       for {
           select {
           case <-ctx.Done():
               //get value
               fmt.Println(ctx.Value(key), "is cancel")
   
               return
           default:
               //get value
               fmt.Println(ctx.Value(key), "int goroutine")
   
               time.Sleep(2 * time.Second)
           }
       }
   }
   

    

3. 超时取消 context.WithTimeout

   package main
   
   import (
       "fmt"
       "sync"
       "time"
   
       "golang.org/x/net/context"
   )
   
   var (
       wg sync.WaitGroup
   )
   
   func work(ctx context.Context) error {
       defer wg.Done()
   
       for i := 0; i < 1000; i++ {
           select {
           case <-time.After(2 * time.Second):
               fmt.Println("Doing some work ", i)
   
           // we received the signal of cancelation in this channel
           case <-ctx.Done():
               fmt.Println("Cancel the context ", i)
               return ctx.Err()
           }
       }
       return nil
   }
   
   func main() {
       ctx, cancel := context.WithTimeout(context.Background(), 4*time.Second)
       defer cancel()
   
       fmt.Println("Hey, I‘m going to do some work")
   
       wg.Add(1)
       go work(ctx)
       wg.Wait()
   
       fmt.Println("Finished. I‘m going home")
   }
   

    

4. 截止时间 取消 context.WithDeadline

   package main
   
   import (
       "context"
       "fmt"
       "time"
   )
   
   func main() {
       d := time.Now().Add(1 * time.Second)
       ctx, cancel := context.WithDeadline(context.Background(), d)
   
       // Even though ctx will be expired, it is good practice to call its
       // cancelation function in any case. Failure to do so may keep the
       // context and its parent alive longer than necessary.
       defer cancel()
   
       select {
       case <-time.After(2 * time.Second):
           fmt.Println("oversleep")
       case <-ctx.Done():
           fmt.Println(ctx.Err())
       }
   }
   

    

参考：https://www.jianshu.com/p/e5df3cd0708b