AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Go 语言基础之 Context 详解

2023-09-07 145
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 在 Go 语言中，Context 是一个非常重要的概念，它用于在不同的 goroutine 之间传递请求域的相关数据，并且可以用来控制 goroutine 的生命周期和取消操作。本文将深入探讨 Go 语言中 Context 特性 和 Context 的高级使用方法。

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

image.png

前言

在 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 的时候，需要注意以下几点：

  • 在创建 goroutine 时，需要将原始 Context 对象作为参数传递给它。
  • 在 goroutine 中，需要使用传递的 Context 对象来进行取消操作，以便能够及时释放相关的资源。
  • Context 的传递时，需要保证传递的 Context 对象是原始 Context 对象的子 Context，以便在需要取消操作时能够同时取消所有相关的 goroutine。
  • 在使用 WithCancel 和 WithTimeout 方法创建 Context 对象时，需要及时调用 cancel 函数，以便能够及时释放资源。
  • 在一些场景下，可以使用 WithValue 方法将数据存储到 Context 中，以便在不同的 goroutine 之间共享数据。

文章标签：
Go
数据库
安全
存储
关键词：
Go语言
Go语言Context
Go context
程序员祝融
目录
相关文章
游客sjjs6jgz4gp7m1
|
1天前
|
Java 编译器 Go
探索Go语言的性能优化技巧
在本文中，我们将深入探讨Go语言的底层机制，以及如何通过代码层面的优化来提升程序性能。我们将讨论内存管理、并发控制以及编译器优化等关键领域，为你提供一系列实用的技巧和最佳实践。
游客sjjs6jgz4gp7m1
17 7
游客5fdji2pvmf8888
|
1天前
|
Cloud Native Go API
Go语言在微服务架构中的创新应用与实践
本文深入探讨了Go语言在构建高效、可扩展的微服务架构中的应用。Go语言以其轻量级协程（goroutine）和强大的并发处理能力，成为微服务开发的首选语言之一。通过实际案例分析，本文展示了如何利用Go语言的特性优化微服务的设计与实现，提高系统的响应速度和稳定性。文章还讨论了Go语言在微服务生态中的角色，以及面临的挑战和未来发展趋势。
游客5fdji2pvmf8888
10 6
游客5fdji2pvmf8888
|
1天前
|
安全 Go 调度
探索Go语言的并发模式：协程与通道的协同作用
Go语言以其并发能力闻名于世，而协程（goroutine）和通道（channel）是实现并发的两大利器。本文将深入了解Go语言中协程的轻量级特性，探讨如何利用通道进行协程间的安全通信，并通过实际案例演示如何将这两者结合起来，构建高效且可靠的并发系统。
游客5fdji2pvmf8888
10 5
游客5fdji2pvmf8888
|
1天前
|
安全 Go 开发者
破译Go语言中的并发模式：从入门到精通
在这篇技术性文章中，我们将跳过常规的摘要模式，直接带你进入Go语言的并发世界。你将不会看到枯燥的介绍，而是一段代码的旅程，从Go的并发基础构建块（goroutine和channel）开始，到高级模式的实践应用，我们共同探索如何高效地使用Go来处理并发任务。准备好，让Go带你飞。
游客5fdji2pvmf8888
14 4
叫个什么名字
|
2天前
|
运维 Go 开发者
Go语言在微服务架构中的应用与优势
本文深入探讨了Go语言在构建微服务架构中的独特优势和实际应用。通过分析Go语言的核心特性，如简洁的语法、高效的并发处理能力以及强大的标准库支持，我们揭示了为何Go成为开发高性能微服务的首选语言。文章还详细介绍了Go语言在微服务架构中的几个关键应用场景，包括服务间通信、容器化部署和自动化运维等，旨在为读者提供实用的技术指导和启发。
叫个什么名字
10 3
游客sjjs6jgz4gp7m1
|
2天前
|
安全 Go 调度
探索Go语言的并发之美：goroutine与channel
在这个快节奏的技术时代，Go语言以其简洁的语法和强大的并发能力脱颖而出。本文将带你深入Go语言的并发机制，探索goroutine的轻量级特性和channel的同步通信能力，让你在高并发场景下也能游刃有余。
游客sjjs6jgz4gp7m1
10 2
游客sjjs6jgz4gp7m1
|
3天前
|
Go 开发者
Go语言中的并发编程：从基础到实践
在当今的软件开发中，并发编程已经成为了一项不可或缺的技能。Go语言以其简洁的语法和强大的并发支持，成为了开发者们的首选。本文将带你深入了解Go语言中的并发编程，从基础概念到实际应用，帮助你掌握这一重要的编程技能。
游客sjjs6jgz4gp7m1
7 1
353iqifkhsbmw
|
4天前
|
Go
使用go语言将A助手加入项目中
使用go语言将A助手加入项目中
353iqifkhsbmw
12 2
游客762btuqu5wybw666
|
6天前
|
负载均衡 Go API
探索Go语言在微服务架构中的应用与优势
在这篇技术性文章中，我们将深入探讨Go语言（又称为Golang）在构建微服务架构时的独特优势。文章将通过对比分析Go语言与其他主流编程语言，展示Go在并发处理、性能优化、以及开发效率上的优势。同时，我们将通过一个实际的微服务案例，详细说明如何利用Go语言构建高效、可扩展的微服务系统。
游客762btuqu5wybw666
25 4
游客5fdji2pvmf8888
|
4天前
|
Go 数据处理 调度
Go语言中的并发模型：解锁高效并行编程的秘诀
本文将探讨Go语言中独特的并发模型及其在现代软件开发中的应用。通过深入分析 Goroutines 和 Channels，我们将揭示这一模型如何简化并行编程，提升应用性能，并改变开发者处理并发任务的方式。不同于传统多线程编程，Go的并发方法以其简洁性和高效性脱颖而出，为开发者提供了一种全新的编程范式。
游客5fdji2pvmf8888
11 1

热门文章

最新文章

  • 1
    GO语言数组
  • 2
    老年人编译系列-go cmd/dist源码
  • 3
    golang开发:类库篇(四)配置文件解析器goconfig的使用
  • 4
    Go语言之基准测试
  • 5
    go语言多态接口样例
  • 6
    Go --- go-elasticsearch介绍及简单使用
  • 7
    go语言时间类型、字符串转换为时间、时间转换为字符串
  • 8
    go语言方法实例
  • 9
    go包管理速通，一篇文章就够了，再也不用担心因为不会导包被辞退
  • 10
    go8---函数function
  • 1
    Go语言的入门学习
    55
  • 2
    3137. K 周期字符串需要的最少操作次数[go语言中map学习]
    44
  • 3
    Golang深入浅出之-Go语言中的分布式计算框架Apache Beam
    220
  • 4
    Go语言中的分布式ID生成器设计与实现
    189
  • 5
    Go语言中的分布式锁实现与选型
    256
  • 6
    Go语言中的分布式事务处理方案
    154
  • 7
    多范式编程语言Go：并发与静态类型的结合
    69
  • 8
    Golang深入浅出之-Go语言中的持续集成与持续部署（CI/CD）
    166
  • 9
    Golang深入浅出之-Go语言中的云原生开发：Kubernetes与Docker
    165
  • 10
    Golang深入浅出之-Go语言中的服务网格（Service Mesh）原理与应用
    437

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践
    • 下一篇
    AI助理直击要害，从繁复中提炼精华——使用CDN加速访问OSS存储的图片