关于go:Go-语言基础之-Context-详解

29次阅读

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

之前有兄弟留言想学习一下 Context,他来了,虽迟但到。

前言

在 Go 语言中,Context 是一个十分重要的概念,它用于在不同的 goroutine 之间传递申请域的相干数据,并且能够用来管制 goroutine 的生命周期和勾销操作。本文将深入探讨 Go 语言中 Context 个性 和 Context 的高级应用办法。

根本用法

在 Go 语言中,Context 被定义为一个接口类型,它蕴含了三个办法:

# go version 1.18.10
type Context interface {Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
      Value(key any) any
}
  • Deadline() 办法用于获取 Context 的截止工夫,
  • Done() 办法用于返回一个只读的 channel,用于告诉以后 Context 是否曾经被勾销,
  • Err() 办法用于获取 Context 勾销的起因,
  • Value() 办法用于获取 Context 中保留的键值对数据。

咱们日常编写代码时,Context 对象会被被约定作为函数的第一个参数传递,eg:

func users(ctx context.Context, request *Request) {// ... code}

在函数中,能够通过 ctx 参数来获取相干的 Context 数据,举个超时的 eg:

deadline, ok := ctx.Deadline()
if ok && deadline.Before(time.Now()) {
    // 超时
    return
}

Context 管制 goroutine 的生命周期

在 Go 语言中,goroutine 是一种十分常见的并发编程模型,而 Context 能够被用来管制 goroutine 的生命周期,从而避免出现 goroutine 透露或者不必要的期待操作。

eg,看一下下方代码:

func users(ctx context.Context, req *Request) {
    // 启动一个 goroutine 来解决申请
    go func() {// 解决申请...}()}

下面的代码中,咱们启动了一个 goroutine 来解决申请,然而没有任何形式来管制这个 goroutine 的生命周期,如果这个申请被勾销了,那么这个 goroutine 就会始终存在,直到它实现为止。为了防止这种状况的产生,咱们能够应用 Context 来管制 goroutine 的生命周期,eg:

func users(ctx context.Context, req *Request) {
    // 启动一个 goroutine 来解决申请
    go func(ctx context.Context) {// 解决申请...}(ctx)
}

在下面的代码中,咱们将 Context 对象作为参数传递给了 goroutine 函数,这样在申请被勾销时,goroutine 就能够及时退出。

应用 WithValue() 传递数据

除了用于管制 goroutine 的生命周期,Context 还能够被用来在不同的 goroutine 之间传递申请域的相干数据。为了实现这个目标,咱们能够应用 Context 的 WithValue() 办法,eg:

type key int

const (userKey key = iota)

func users(ctx context.Context, req *Request) {
    // 从申请中获取用户信息
    user := req.GetUser
    // 将用户信息保留到 Context 中
    ctx = context.WithValue(ctx, userKey, user)
    
    // 启动一个 goroutine 来解决申请
    go func(ctx context.Context) {
        // 从 Context 中获取用户信息
        user := ctx.Value(userKey).(*User)
    
        // 解决申请...
    }(ctx)

}
    
    

在下面的代码中,咱们定义了一个 key 类型的常量 userKey,而后在 users() 函数中将用户信息保留到了 Context 中,并将 Context 对象传递给了 goroutine 函数。

在 goroutine 函数中,咱们应用 ctx.Value() 办法来获取 Context 中保留的用户信息。

注:

Context 中保留的键值对数据应该是线程平安的,因为它们可能会在多个 goroutine 中同时拜访。

应用 WithCancel() 勾销操作

除了管制 goroutine 的生命周期和传递数据之外,Context 还能够被用来执行勾销操作。为了实现这个目标,咱们能够应用 Context 的 WithCancel() 办法,eg:

func users(ctx context.Context, req *Request) {
    // 创立一个能够勾销的 Context 对象
    ctx, cancel := context.WithCancel(ctx)

    // 启动一个 goroutine 来解决申请
    go func(ctx context.Context) {
        // 期待申请实现或者被勾销
        select {case <-time.After(time.Second):
            // 申请实现
            fmt.Println("Request finish")
        case <-ctx.Done():
            // 申请被勾销
            fmt.Println("Request canceled")
        }
    }(ctx)

    // 期待一段时间后勾销申请
    time.Sleep(time.Millisecond * 800)
    cancel()}

在下面的代码中,咱们应用 WithCancel() 办法创立了一个能够勾销的 Context 对象,并将勾销操作封装在了一个 cancel() 函数中。而后咱们启动了一个 goroutine 函数,应用 select 语句期待申请实现或者被勾销,最初在主函数中期待一段时间后调用 cancel() 函数来勾销申请。

应用 WithDeadline() 设置截止工夫

除了应用 WithCancel() 办法进行勾销操作之外,Context 还能够被用来设置截止工夫,以便在超时的状况下勾销申请。为了实现这个目标,咱们能够应用 Context 的 WithDeadline() 办法,eg:

func users(ctx context.Context, req *Request) {
    // 设置申请的截止工夫为以后工夫加上 1 秒钟
    ctx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Second))

    // 启动一个 goroutine 来解决申请
    go func(ctx context.Context) {
        // 期待申请实现或者超时
        select {case <-time.After(time.Millisecond * 500):
            // 申请实现
            fmt.Println("Request finish")
            case <-ctx.Done():
            // 申请超时或者被勾销
            fmt.Println("Request canceled or timed out")
        }
    }(ctx)

    // 期待一段时间后勾销申请
    time.Sleep(time.Millisecond * 1500)
    cancel()}

在下面的代码中,咱们应用 WithDeadline() 办法设置了一个截止工夫为以后工夫加上 1 秒钟的 Context 对象,并将超时操作封装在了一个 cancel() 函数中。而后咱们启动了一个 goroutine 函数,应用 select 语句期待申请实现或者超时,最初在主函数中期待一段时间后调用 cancel() 函数来勾销申请。

注:

在应用 WithDeadline() 办法设置截止工夫的时候,如果截止工夫曾经过期,则 Context 对象将被立刻勾销。

应用 WithTimeout() 设置超时工夫

除了应用 WithDeadline() 办法进行截止工夫设置之外,Context 还能够被用来设置超时工夫。为了实现这个目标,咱们能够应用 Context 的 WithTimeout() 办法,eg:

func users(ctx context.Context, req *Request) {
    // 设置申请的超时工夫为 1 秒钟
    ctx, cancel := context.WithTimeout(ctx, time.Second)

    // 启动一个 goroutine 来解决申请
    go func(ctx context.Context) {
        // 期待申请实现或者超时
        select {case <-time.After(time.Millisecond * 500):
            // 申请实现
            fmt.Println("Request completed")
        case <-ctx.Done():
            // 申请超时或者被勾销
            fmt.Println("Request canceled or timed out")
        }
    }(ctx)

    // 期待一段时间后勾销申请
    time.Sleep(time.Millisecond * 1500)
    cancel()}

在下面的代码中,咱们应用 WithTimeout() 办法设置了一个超时工夫为 1 秒钟的 Context 对象,并将超时操作封装在了一个 cancel() 函数中。而后咱们启动了一个 goroutine 函数,应用 select 语句期待申请实现或者超时,最初在主函数中期待一段时间后调用 cancel() 函数来勾销申请。

注:

须要留神的是,在应用 WithTimeout() 办法设置超时工夫的时候,如果超时工夫曾经过期,则 Context 对象将被立刻勾销。

Context 的传递

在一个应用程序中,不同的 goroutine 可能须要共享同一个 Context 对象。为了实现这个目标,Context 对象能够通过函数调用或者网络传输等形式进行传递。

例如,咱们能够在一个解决 HTTP 申请的函数中创立一个 Context 对象,并将它作为参数传递给一个数据库查问函数,以便在查问过程中应用这个 Context 对象进行勾销操作。代码 eg:

func users(ctx context.Context, req *Request) {
    // 在解决 HTTP 申请的函数中创立 Context 对象
    ctx, cancel := context.WithTimeout(ctx, time.Second)
    defer cancel()

    // 调用数据库查问函数并传递 Context 对象
    result, err := findUserByName(ctx, req)
    if err != nil {// 解决查问谬误...}

    // 解决查问后果...
}

func findUserByName(ctx context.Context, req *Request) (*Result, error) {
    // 在数据库查问函数中应用传递的 Context 对象
    rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE name = ?", req.Name)
    if err != nil {// 解决查问谬误...}
      defer rows.Close()
      // 解决查问后果...
}

在下面的代码中,咱们在解决 HTTP 申请的函数中创立了一个 Context 对象,并将它作为参数传递给了一个数据库查问函数 findUserByName()。在 findUserByName() 函数中,咱们应用传递的 Context 对象来调用 db.QueryContext() 办法进行查问操作。因为传递的 Context 对象可能会在查问过程中被勾销,因而咱们须要在查问实现后查看查问操作的谬误,以便进行相应的解决。

注:

在进行 Context 的传递时,咱们须要保障传递的 Context 对象是原始 Context 对象的子 Context,以便在须要勾销操作时可能同时勾销所有相干的 goroutine。如果传递的 Context 对象不是原始 Context 对象的子 Context,则勾销操作只会影响到以后 goroutine,而无奈勾销其余相干的 goroutine。

总结

在 Go 语言中,Context 是一个十分重要的个性,包含其根本用法和一些高级用法。Context 能够用于治理 goroutine 的生命周期和勾销操作,避免出现资源透露和死锁等问题,同时也能够进步应用程序的性能和可维护性。

在应用 Context 的时候, 须要留神以下几点:

    1. 在创立 goroutine 时,须要将原始 Context 对象作为参数传递给它。
    1. 在 goroutine 中,须要应用传递的 Context 对象来进行勾销操作,以便可能及时开释相干的资源。
    1. Context 的传递时,须要保障传递的 Context 对象是原始 Context 对象的子 Context,以便在须要勾销操作时可能同时勾销所有相干的 goroutine。
    1. 在应用 WithCancel 和 WithTimeout 办法创立 Context 对象时,须要及时调用 cancel 函数,以便可能及时开释资源。
    1. 在一些场景下,能够应用 WithValue 办法将数据存储到 Context 中,以便在不同的 goroutine 之间共享数据。

正文完
 0