关于golang:Golang-一文带你快速入门context

45次阅读

共计 3000 个字符,预计需要花费 8 分钟才能阅读完成。

前言

Go1.7 引入了 context 包,其中定义了多种上下文,包含可被动勾销的上下文,带截止工夫或超时工夫的上下文,带值流传的上下文

context包的引入意义不凡,它能够让信息(如:用户信息)在协程之间传递变得更加便捷,也能够把控一组协程的退出机会

假如,以后有一个函数 gen,它承受context 入参,作用是创立一个无缓冲区的 channel,起一个 协程 每秒往这个通道中塞入一个信号,当 context 完结时,敞开通道,协程失常退出

func gen(ctx context.Context) chan struct{} {c := make(chan struct{})
    go func() {
        for {
            select {case <-ctx.Done(): // [1]context 完结
                fmt.Println("receive context done signal, closing channel now")
                close(c) // 敞开通道
                return // groutine 失常退出
            default:
                c <- struct{}{} // [2]应用空构造体节俭内存
            }
            time.Sleep(time.Second)
        }
    }()
    return c
}

接下来,通过几个简略的例子来体验一下 context 包提供的各种类型的上下文

例子 1:可被动勾销的上下文

通过 contextWithCancel函数,能够创立一个反对被动勾销的上下文

func UseCancelContext() {ctx, cancelFunc := context.WithCancel(context.Background())
    go func() {time.AfterFunc(time.Second*5, func() {// [1] 五秒后执行勾销上下文的操作
            cancelFunc()
            fmt.Println("send context done signal")
        })
    }()
    for range gen(ctx) {fmt.Println("receive signal from another goroutine")
    }
    fmt.Println("main goroutine is finished")
}

[1]处被动调用 cancelFunc,其底层逻辑就是敞开以后上下文及其子上下文中的通道,当上下文中的通道被敞开时,<-ctx.Done() 就会有值,gen函数中的 select 会抉择case <-ctx.Done(),而后执行敞开通道,退出协程

函数执行后果如下,能够看到,gen 函数中的协程在发送了五次信号后,敞开了通道,失常退出协程

<img src=”https://images-1255831004.cos.ap-guangzhou.myqcloud.com/online/2021-07-05-132126.png” alt=”image-20210705212126405″ style=”zoom:50%;” />

例子 2:带截止工夫的上下文

通过 contextWithDeadline函数,能够创立一个带截止工夫的上下文

func UseDeadlineContext() {
  // 创立一个截止工夫为五秒后的上下文
    ctx, cancelFunc := context.WithDeadline(context.Background(), time.Now().Add(time.Second*5))
    defer cancelFunc() // [1]请思考一下为什么要这样做?for range gen(ctx) {fmt.Println("receive signal from another goroutine")
    }
    fmt.Println("main goroutine is finished")
}

上述函数创立了一个截止工夫为五秒后的上下文,该上下文会在五秒后敞开通道

<img src=”https://images-1255831004.cos.ap-guangzhou.myqcloud.com/online/2021-07-05-133503.png” alt=”image-20210705213503229″ style=”zoom:50%;” />

例子 3:带超时工夫的上下文

通过 contextWithTimeout函数,能够创立一个带超时工夫的上下文

func UseTimeoutContext() {ctx, cancelFunc := context.WithTimeout(context.Background(), time.Second*5)
    defer cancelFunc()
    for range gen(ctx) {fmt.Println("receive signal from another goroutine")
    }
    fmt.Println("main goroutine is finished")
}

上述函数中创立了一个带五秒超时工夫的上下文,代码执行后果

<img src=”https://images-1255831004.cos.ap-guangzhou.myqcloud.com/online/2021-07-05-133737.png” alt=”image-20210705213737346″ style=”zoom:50%;” />

例子 4:带值流传的上下文

通过 contextWithValue函数,能够创立一个带值流传的上下文

func UseValueContext() {
  // 创立一个带值的上下文, 键值对 <1,"value">
    ctx := context.WithValue(context.Background(), 1, "value")
    c := make(chan struct{})
    go func() {time.Sleep(time.Second * 1)
    // 从上下文中获取对应的值
        value := ctx.Value(1)
        fmt.Printf("get value from ctx, value = %s\n", value)
        c <- struct{}{}
    }()
    <-c
    fmt.Println("main goroutine is finished")
}

执行后果

<img src=”https://images-1255831004.cos.ap-guangzhou.myqcloud.com/online/2021-07-05-134207.png” alt=”image-20210705214206616″ style=”zoom:50%;” />

总结

日常开发中须要应用 context 包的场景十分多,简略举几个例子:

  1. 从申请上下文中获取用户信息
  2. 从申请上下文中获取申请的惟一标识(traceId,罕用于分布式日志追踪)
  3. 管制申请超时工夫

能够看到,通过 context 包,咱们更容易实现信息在一组协程之间的流传,也更好地把控多个协程的退出机会

Go 也重写了很多规范库来反对 context 包

同时 Go 官网倡议上下文不应该嵌入到构造体中应用,而是 应该将上下文作为调用函数 / 办法的第一个参数应用,并举荐参数命名为ctx

// 不举荐
type ModuleContext struct {c context.Context}
// 举荐
func func1(ctx context.Context, opts ...Option)

把握这个包的应用和理解其中原理是很有必要的

下一篇文章我将会解答在这篇文章中的留下的疑难(例子 2 [1] 处),以及进一步开掘 context 包源码

正文完
 0