go标准库Context上下文

为什么需要Context

基本示例

package mainimport ("fmt""sync""time"
)var wg sync.WaitGroup// 初始的例子func worker() {for {fmt.Println("worker")time.Sleep(time.Second)}// 如何接收外部命令实现退出wg.Done()
}func main() {wg.Add(1)go worker()// 如何优雅的实现结束子goroutinewg.Wait()fmt.Println("over")
}

全局变量方式

package mainimport ("fmt""sync""time"
)var wg sync.WaitGroup
var exit bool// 全局变量方式存在的问题：
// 1. 使用全局变量在跨包调用时不容易统一
// 2. 如果worker中再启动goroutine，就不太好控制了。func worker() {for {fmt.Println("worker")time.Sleep(time.Second)if exit {break}}wg.Done()
}func main() {wg.Add(1)go worker()time.Sleep(time.Second * 3) // sleep3秒以免程序过快退出exit = true                 // 修改全局变量实现子goroutine的退出wg.Wait()fmt.Println("over")
}

通道方式

package mainimport ("fmt""sync""time"
)var wg sync.WaitGroup// 管道方式存在的问题：
// 1. 使用全局变量在跨包调用时不容易实现规范和统一，需要维护一个共用的channelfunc worker(exitChan chan struct{}) {
LOOP:for {fmt.Println("worker")time.Sleep(time.Second)select {case <-exitChan: // 等待接收上级通知break LOOPdefault:}}wg.Done()
}func main() {var exitChan = make(chan struct{})wg.Add(1)go worker(exitChan)time.Sleep(time.Second * 3) // sleep3秒以免程序过快退出exitChan <- struct{}{}      // 给子goroutine发送退出信号close(exitChan)wg.Wait()fmt.Println("over")
}

官方版的方案

package mainimport ("context""fmt""sync""time"
)var wg sync.WaitGroupfunc worker(ctx context.Context) {
LOOP:for {fmt.Println("worker")time.Sleep(time.Second)select {case <-ctx.Done(): // 等待上级通知break LOOPdefault:}}wg.Done()
}func main() {ctx, cancel := context.WithCancel(context.Background())wg.Add(1)go worker(ctx)time.Sleep(time.Second * 3)cancel() // 通知子goroutine结束wg.Wait()fmt.Println("over")
}

当子goroutine又开启另外一个goroutine时，只需要将ctx传入即可：

package mainimport ("context""fmt""sync""time"
)var wg sync.WaitGroupfunc worker(ctx context.Context) {go worker2(ctx)
LOOP:for {fmt.Println("worker")time.Sleep(time.Second)select {case <-ctx.Done(): // 等待上级通知break LOOPdefault:}}wg.Done()
}func worker2(ctx context.Context) {
LOOP:for {fmt.Println("worker2")time.Sleep(time.Second)select {case <-ctx.Done(): // 等待上级通知break LOOPdefault:}}
}
func main() {ctx, cancel := context.WithCancel(context.Background())wg.Add(1)go worker(ctx)time.Sleep(time.Second * 3)cancel() // 通知子goroutine结束wg.Wait()fmt.Println("over")
}

Context介绍

Go1.7加入了一个新的标准库context，它定义了Context类型，专门用来简化 对于处理单个请求的多个 goroutine 之间与请求域的数据、取消信号、截止时间等相关操作，这些操作可能涉及多个 API 调用。

对服务器传入的请求应该创建上下文，而对服务器的传出调用应该接受上下文。它们之间的函数调用链必须传递上下文，或者可以使用WithCancel、WithDeadline、WithTimeout或WithValue创建的派生上下文。当一个上下文被取消时，它派生的所有上下文也被取消。

Context接口

context.Context是一个接口，该接口定义了四个需要实现的方法。具体签名如下：

type Context interface {Deadline() (deadline time.Time, ok bool)Done() <-chan struct{}Err() errorValue(key interface{}) interface{}
}

其中：

  • Deadline方法需要返回当前Context被取消的时间，也就是完成工作的截止时间（deadline）；
  • Done方法需要返回一个Channel，这个Channel会在当前工作完成或者上下文被取消之后关闭，多次调用Done方法会返回同一个Channel；
  • Err方法会返回当前Context结束的原因，它只会在Done返回的Channel被关闭时才会返回非空的值；
    • 如果当前Context被取消就会返回Canceled错误；
    • 如果当前Context超时就会返回DeadlineExceeded错误；
  • Value方法会从Context中返回键对应的值，对于同一个上下文来说，多次调用Value 并传入相同的Key会返回相同的结果，该方法仅用于传递跨API和进程间跟请求域的数据；

Background()和TODO()

Go内置两个函数：Background()和TODO()，这两个函数分别返回一个实现了Context接口的background和todo。我们代码中最开始都是以这两个内置的上下文对象作为最顶层的partent context，衍生出更多的子上下文对象。

Background()主要用于main函数、初始化以及测试代码中，作为Context这个树结构的最顶层的Context，也就是根Context。

TODO()，它目前还不知道具体的使用场景，如果我们不知道该使用什么Context的时候，可以使用这个。

background和todo本质上都是emptyCtx结构体类型，是一个不可取消，没有设置截止时间，没有携带任何值的Context。

With系列函数

此外，context包中还定义了四个With系列函数。

WithCancel

WithCancel的函数签名如下：

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

WithCancel返回带有新Done通道的父节点的副本。当调用返回的cancel函数或当关闭父上下文的Done通道时，将关闭返回上下文的Done通道，无论先发生什么情况。

取消此上下文将释放与其关联的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel。

func gen(ctx context.Context) <-chan int {dst := make(chan int)n := 1go func() {for {select {case <-ctx.Done():return // return结束该goroutine，防止泄露case dst <- n:n++}}}()return dst}
func main() {ctx, cancel := context.WithCancel(context.Background())defer cancel() // 当我们取完需要的整数后调用cancelfor n := range gen(ctx) {fmt.Println(n)if n == 5 {break}}
}

上面的示例代码中，gen函数在单独的goroutine中生成整数并将它们发送到返回的通道。 gen的调用者在使用生成的整数之后需要取消上下文，以免gen启动的内部goroutine发生泄漏。

WithDeadline

WithDeadline的函数签名如下：

func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)

返回父上下文的副本，并将deadline调整为不迟于d。如果父上下文的deadline已经早于d，则WithDeadline(parent, d)在语义上等同于父上下文。当截止日过期时，当调用返回的cancel函数时，或者当父上下文的Done通道关闭时，返回上下文的Done通道将被关闭，以最先发生的情况为准。

取消此上下文将释放与其关联的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel。

func main() {d := time.Now().Add(50 * time.Millisecond)ctx, cancel := context.WithDeadline(context.Background(), d)// 尽管ctx会过期，但在任何情况下调用它的cancel函数都是很好的实践。// 如果不这样做，可能会使上下文及其父类存活的时间超过必要的时间。defer cancel()select {case <-time.After(1 * time.Second):fmt.Println("overslept")case <-ctx.Done():fmt.Println(ctx.Err())}
}

上面的代码中，定义了一个50毫秒之后过期的deadline，然后我们调用context.WithDeadline(context.Background(), d)得到一个上下文（ctx）和一个取消函数（cancel），然后使用一个select让主程序陷入等待：等待1秒后打印overslept退出或者等待ctx过期后退出。

在上面的示例代码中，因为ctx 50毫秒后就会过期，所以ctx.Done()会先接收到context到期通知，并且会打印ctx.Err()的内容。

WithTimeout

WithTimeout的函数签名如下：

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

WithTimeout返回WithDeadline(parent, time.Now().Add(timeout))。

取消此上下文将释放与其相关的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel，通常用于数据库或者网络连接的超时控制。具体示例如下：

package mainimport ("context""fmt""sync""time"
)// context.WithTimeoutvar wg sync.WaitGroupfunc worker(ctx context.Context) {
LOOP:for {fmt.Println("db connecting ...")time.Sleep(time.Millisecond * 10) // 假设正常连接数据库耗时10毫秒select {case <-ctx.Done(): // 50毫秒后自动调用break LOOPdefault:}}fmt.Println("worker done!")wg.Done()
}func main() {// 设置一个50毫秒的超时ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)wg.Add(1)go worker(ctx)time.Sleep(time.Second * 5)cancel() // 通知子goroutine结束wg.Wait()fmt.Println("over")
}

WithValue

WithValue函数能够将请求作用域的数据与 Context 对象建立关系。声明如下：

func WithValue(parent Context, key, val interface{}) Context

WithValue返回父节点的副本，其中与key关联的值为val。

仅对API和进程间传递请求域的数据使用上下文值，而不是使用它来传递可选参数给函数。

所提供的键必须是可比较的，并且不应该是string类型或任何其他内置类型，以避免使用上下文在包之间发生冲突。WithValue的用户应该为键定义自己的类型。为了避免在分配给interface{}时进行分配，上下文键通常具有具体类型struct{}。或者，导出的上下文关键变量的静态类型应该是指针或接口。

package mainimport ("context""fmt""sync""time"
)// context.WithValuetype TraceCode stringvar wg sync.WaitGroupfunc worker(ctx context.Context) {key := TraceCode("TRACE_CODE")traceCode, ok := ctx.Value(key).(string) // 在子goroutine中获取trace codeif !ok {fmt.Println("invalid trace code")}
LOOP:for {fmt.Printf("worker, trace code:%s\n", traceCode)time.Sleep(time.Millisecond * 10) // 假设正常连接数据库耗时10毫秒select {case <-ctx.Done(): // 50毫秒后自动调用break LOOPdefault:}}fmt.Println("worker done!")wg.Done()
}func main() {// 设置一个50毫秒的超时ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)// 在系统的入口中设置trace code传递给后续启动的goroutine实现日志数据聚合ctx = context.WithValue(ctx, TraceCode("TRACE_CODE"), "12512312234")wg.Add(1)go worker(ctx)time.Sleep(time.Second * 5)cancel() // 通知子goroutine结束wg.Wait()fmt.Println("over")
}

使用Context的注意事项

  • 推荐以参数的方式显示传递Context
  • 以Context作为参数的函数方法，应该把Context作为第一个参数。
  • 给一个函数方法传递Context的时候，不要传递nil，如果不知道传递什么，就使用context.TODO()
  • Context的Value相关方法应该传递请求域的必要数据，不应该用于传递可选参数
  • Context是线程安全的，可以放心的在多个goroutine中传递

客户端超时取消示例

调用服务端API时如何在客户端实现超时控制？

server端

// context_timeout/server/main.go
package mainimport ("fmt""math/rand""net/http""time"
)// server端，随机出现慢响应func indexHandler(w http.ResponseWriter, r *http.Request) {number := rand.Intn(2)if number == 0 {time.Sleep(time.Second * 10) // 耗时10秒的慢响应fmt.Fprintf(w, "slow response")return}fmt.Fprint(w, "quick response")
}func main() {http.HandleFunc("/", indexHandler)err := http.ListenAndServe(":8000", nil)if err != nil {panic(err)}
}

client端

// context_timeout/client/main.go
package mainimport ("context""fmt""io/ioutil""net/http""sync""time"
)// 客户端type respData struct {resp *http.Responseerr  error
}func doCall(ctx context.Context) {transport := http.Transport{// 请求频繁可定义全局的client对象并启用长链接// 请求不频繁使用短链接DisableKeepAlives: true, 	}client := http.Client{Transport: &transport,}respChan := make(chan *respData, 1)req, err := http.NewRequest("GET", "http://127.0.0.1:8000/", nil)if err != nil {fmt.Printf("new requestg failed, err:%v\n", err)return}req = req.WithContext(ctx) // 使用带超时的ctx创建一个新的client requestvar wg sync.WaitGroupwg.Add(1)defer wg.Wait()go func() {resp, err := client.Do(req)fmt.Printf("client.do resp:%v, err:%v\n", resp, err)rd := &respData{resp: resp,err:  err,}respChan <- rdwg.Done()}()select {case <-ctx.Done()://transport.CancelRequest(req)fmt.Println("call api timeout")case result := <-respChan:fmt.Println("call server api success")if result.err != nil {fmt.Printf("call server api failed, err:%v\n", result.err)return}defer result.resp.Body.Close()data, _ := ioutil.ReadAll(result.resp.Body)fmt.Printf("resp:%v\n", string(data))}
}func main() {// 定义一个100毫秒的超时ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)defer cancel() // 调用cancel释放子goroutine资源doCall(ctx)
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/653203.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

不确定优化入门：用简单实例讲明白随机规划、鲁棒优化和分布鲁棒优化

不确定优化入门：用简单实例讲明白随机规划、鲁棒优化和分布鲁棒优化

文章目录 1 引言2 学习动机3 经典问题4 解决方案4.1 忽略不确定性4.2 随机规划4.3 鲁棒优化4.4 分布鲁棒优化 5 总结相关阅读 1 引言 按2024的原定计划&#xff0c;今年开始要学习不确定优化了。 粗略翻阅了一些相关的书籍和教程&#xff0c;大都包含许多数学公式&#xff0c…
阅读更多...
SpringBoot引入主盘探活定时任务

SpringBoot引入主盘探活定时任务

主盘探活通常是指检查存储设备&#xff08;例如硬盘&#xff09;是否可读写&#xff0c;但在Java中并没有直接针对硬件级别的磁盘探活API。然而&#xff0c;我们可以模拟一个场景&#xff0c;即检查某个目录或文件是否可以被Java程序正常读写&#xff0c;以此作为主盘活跃的一个…
阅读更多...
HCIP复习课（bgp实验）

HCIP复习课（bgp实验）

1、ip配置&#xff1a; R1&#xff1a; R2&#xff1a; R9&#xff1a; R10&#xff1a; R11&#xff1a; R3&#xff1a; R4&#xff1a; R5&#xff1a; R6&#xff1a; R7&#xff1a; R8&#xff1a; 2、隧道配置&#xff1a; R2&#xff1a; 静态&#xff1a; R10&am…
阅读更多...
第15次修改了可删除可持久保存的前端html备忘录：换了一个容器时钟，匹配背景主题：现代深色

第15次修改了可删除可持久保存的前端html备忘录：换了一个容器时钟，匹配背景主题：现代深色

第15次修改了可删除可持久保存的前端html备忘录&#xff1a;换了一个容器时钟&#xff0c;匹配背景主题&#xff1a;现代深色 备忘录代码 <!DOCTYPE html> <html lang"zh-CN"><head><meta charset"UTF-8"><meta http-equiv&qu…
阅读更多...
Python自动化框架命名约定(函数、模块、包、类等)

Python自动化框架命名约定(函数、模块、包、类等)

命名约定&#xff1a; 1. 所谓"内部(Internal)"表示仅模块内可用&#xff0c;或者&#xff0c;在类内是保护或私有的; 2. 用单下划线(_)开头表示模块变量或函数是protected的(使用import * from时不会包含); 3. 用双下划线(__)开头的实例变量或方法表示类内…
阅读更多...
WSL2 Debian系统添加支持SocketCAN

WSL2 Debian系统添加支持SocketCAN

本人最近在使用WSL2&#xff0c;Linux系统选择的是Debian&#xff0c;用起来很不错&#xff0c;感觉可以代替VMware Player虚拟机。 但是WSL2 Debian默认不支持SocketCAN&#xff0c;这就有点坑了&#xff0c;由于本人经常要使用SocketCAN功能&#xff0c;所以决定让Debian支持…
阅读更多...
Axolotl：一款极简的大模型微调（Finetune）开源框架

Axolotl：一款极简的大模型微调（Finetune）开源框架

今天给大家分享一款工具&#xff0c;Axolotl[1] 是一个旨在简化各种AI模型的微调过程的工具&#xff0c;支持多种配置和架构。 特点&#xff1a; 可训练各种 Huggingface 模型&#xff0c;如 llama、pythia、falcon、mpt支持 fullfinetune、lora、qlora、relora 和 gptq使用简…
阅读更多...
Maven入门及其使用

Maven入门及其使用

目录 一、Maven入门 1.1 初识Maven 1.2 Maven的作用 1.2.1 依赖管理 1.2.2 统一项目结构 1.2.3 项目构建 1.3 Maven坐标 1.4 Maven仓库 1.4.1 Maven仓库概述 二、Maven的下载与安装 2.1 安装步骤 2.1.1 解压安装&#xff08;建议解压到没有中文、特殊字符的路径下。&#xff09…
阅读更多...
数据湖技术之应用场景篇

数据湖技术之应用场景篇

数据湖技术有较多的应用场景&#xff0c;本篇文章是针对一些典型的痛点场景做了一些介绍和说明。比如说在线数据抽取场景原有模式对线上库表产生较大压力&#xff0c;flink多流join维护的大状态导致的稳定性问题等等&#xff0c;具体场景如下图所示&#xff1a; 场景1:在线数据…
阅读更多...
【极数系列】Flink详细入门教程 知识体系 学习路线（01）

【极数系列】Flink详细入门教程 知识体系 学习路线（01）

文章目录 01 引言02 Flink是什么2.1 Flink简介2.2 Flink架构2.3 Flink应用场景2.4 Flink运维 03 Flink环境搭建3.1 Flink服务端环境搭建3.2 Flink部署模式3.3 Flink开发环境搭建 04 Flink数据类型以及序列化4.1 数据类型4.2 数据序列化 05 Flink DataStream API5.1 执行模式5.2…
阅读更多...
车载电子电器架构 —— 多核处理器刷写策略

车载电子电器架构 —— 多核处理器刷写策略

车载电子电器架构 —— 多核处理器刷写策略 我是穿拖鞋的汉子&#xff0c;魔都中坚持长期主义的汽车电子工程师。 老规矩&#xff0c;分享一段喜欢的文字&#xff0c;避免自己成为高知识低文化的工程师&#xff1a; 屏蔽力是信息过载时代一个人的特殊竞争力&#xff0c;任何消…
阅读更多...
嵌入式Linux系统引导过程详解

嵌入式Linux系统引导过程详解

大家好&#xff0c;今天给大家介绍嵌入式Linux系统引导过程详解&#xff0c;文章末尾附有分享大家一个资料包&#xff0c;差不多150多G。里面学习内容、面经、项目都比较新也比较全&#xff01;可进群免费领取。 嵌入式Linux系统引导过程是系统启动的关键环节&#xff0c;它涉及…
阅读更多...
代码随想录刷题笔记-Day10

代码随想录刷题笔记-Day10

1. 用栈实现队列 232.用栈实现队列https://leetcode.cn/problems/implement-queue-using-stacks/description/ 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作&#xff08;push、pop、peek、empty&#xff09;&#xff1a; 实现 MyQueue 类&#xf…
阅读更多...
ID Mapping技术解析：从Redis到Spark GraphX的演进与应用

ID Mapping技术解析：从Redis到Spark GraphX的演进与应用

目录 一、ID Mapping的背景 二、ID Mapping的重要性 三、ID Mapping的方案 3.1 基于Redis的ID Mapping(效率不行)
阅读更多...
Java基础数据结构之反射

Java基础数据结构之反射

一.定义 Java的反射机制是在运行状态中的&#xff0c;对于任意一个类都能知道这个类的所有属性和方法&#xff1b;对于任意一个对象&#xff0c;都能够调用它的任意方法及属性。既然能拿到&#xff0c;我们就可以修改部分类型信息。这种动态获取信息以及动态调用对象方法的功能…
阅读更多...
Django笔记（七）：JWT认证

Django笔记（七）：JWT认证

首 前后端分离的项目更多使用JWT认证——Json Web Token。本文记录djangorestframework-simplejwt的使用方式。文档 安装 pip install djangorestframework-simplejwt 配置settings.py: INSTALLED_APPS [rest_framework_simplejwt, ]REST_FRAMEWORK {DEFAULT_AUTHENTICA…
阅读更多...
第一讲_JavaScript概述及三种使用方式

第一讲_JavaScript概述及三种使用方式

JavaScript概述及三种使用方式 1. JavaScript概述1.1 JavaScript 的作用 2 JavaScript使用方式2.1 行内使用2.2 内部使用2.3 外部使用 1. JavaScript概述 JavaScript主页由三部分组成&#xff1a; ECMAScript&#xff1a;规定 JavaScript 核心&#xff0c;定义了语言的基本语…
阅读更多...
系统架构设计师教程（十九）大数据架构设计理论与实践

系统架构设计师教程（十九）大数据架构设计理论与实践

大数据架构设计理论与实践 19.1 传统数据处理系统存在的问题19.2 大数据处理系统架构分析19.2.1 大数据处理系统面临挑战19.2.2 大数据处理系统架构特征19.3 Lambda架构19.3.1 Lambda架构对大数据处理系统的理解19.3.2 Lambda架构应用场景19.3.3 Lambda架构介绍19.3.4 Lambda架…
阅读更多...
【ASP.NET Core 基础知识】--身份验证和授权--用户认证的基本概念

【ASP.NET Core 基础知识】--身份验证和授权--用户认证的基本概念

用户认证在网络安全中起着至关重要的作用。首先&#xff0c;它可以确保只有经过授权的用户才能访问特定的资源或服务&#xff0c;从而保护了系统和数据的安全。其次&#xff0c;用户认证可以帮助追踪和记录用户的活动&#xff0c;如果出现安全问题&#xff0c;可以追踪到具体的…
阅读更多...
无人机调试开源软件

无人机调试开源软件

无人机调试开源软件有以下几个&#xff1a; MissionPlanner&#xff1a;一款功能丰富的开源软件&#xff0c;支持多种无人机&#xff0c;包括固定翼、多旋翼和直升机。它提供了实时的飞行数据监控、地图导航、任务规划以及详细的参数调整选项。APMPlanner2.0&#xff1a;专为A…
阅读更多...
最新文章

Copyright @ 2022~2023