关于golang的context.WithTimeout的cancel的说明

最新推荐文章于 2024-07-11 14:57:54 发布
最新推荐文章于 2024-07-11 14:57:54 发布
阅读量2w 收藏 11
点赞数 5
分类专栏： golang 文章标签： golang context cancel GC Timeout
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangzhiyang/article/details/65633960
版权

简介

context是一个在go中时常用到的程序包，google官方开发。特别常见的一个应用场景是由一个请求衍生出的各个goroutine之间需要满足一定的约束关系，以实现一些诸如有效期，中止routine树，传递请求全局变量之类的功能。使用context实现上下文功能约定需要在你的方法的传入参数的第一个传入一个context.Context类型的变量。
比如:

  • 上层需要指定超时的情况: ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
  • 上层需要主动取消的情况：ctx, cancel := context.WithCancel(ctx)；需要的地方调用cancel()

问题

对于context包中提供的WithTimeout(本质上调用的是WithDeadline) 方法；官方有这样的说明

// Canceling this context releases resources associated with it, so code should
// call cancel as soon as the operations running in this Context complete:
//
// func slowOperationWithTimeout(ctx context.Context) (Result, error) {
// ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
// defer cancel() // releases resources if slowOperation completes before timeout elapses
// return slowOperation(ctx)
// }

文中说到要尽快调用cancel()用来释放关联的资源，那到底这个cancel做了什么，如果不调用呢？

解释

通过阅读代码可以发现，主要做了四件事）

  1. close(c.done)

    这里c.done,即使没有close，也不会影响GC；猜测是为了防止slowOperation里面又创建的goroutine里面等待c.done，这样可能会阻塞，防止goroutine泄露

  2. 所有的child 调用cancel

    这个就是递归了

  3. delete(p.children, child) 删除自己在上层context的记录

    这个有利于GC，如果不删除掉，这个无用的context对象会一直留着，直到上层对象被GC了

  4. c.timer.Stop() 关闭定时器

    如果在超时发生前，slowOperation结束了，这个时候提前 关闭

但是对于WithTimeout(或者WithDeadline) 有两种情况
1. 一种是发生超时了，这个时候cancel 会自动调用，资源被释放
2. 另一种没有发生超时，也就是slowOperation结束的时候，这个时候需要咱们主动调用cancel；但是即使没有调用，在过期时间到了的时候还是会调用cancel，释放资源

所以：cancel 即使不主动调用，也不影响资源的最终释放，但是提前主动调用，可以尽快的释放，避免等待过期时间之间的浪费；
建议还是按照官方的说明使用，养成良好的习惯，在调用WithTimeout之后defer cancel()

注： 最近在看grpc的源码的时候，就发现了一处没有主动调用cancel的情况；并且给原作者提了一个issue，不过这是因为原作者有特殊用意故意为之的
地址：why not call cancel() after context.WithTimeout, is it a bug or have something another?

正版两只羊
关注
  • 5
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go的context.WithTimeout运用
wangkai6666的博客
07-05 829
context.WithTimeout高级运用
golang-context包学习分享
中华鲟的博客
12-01 359
上下文 Context 上下文 context.Context 是用来设置截止日期、同步信号，传递请求相关值的结构体。 上下文与 Goroutine 有比较密切的关系。 context.Context 是 Go 语言中独特的设计，在其他编程语言中我们很少见到类似的概念。 context.Context 是 Go 语言在 1.7 版本中引入标准库的接口，该接口定义了四个需要实现的方法，其中包括： Deadline — 返回 context.Context 被取消的时间，也就是完成工作的截止日期； Done
Golang context介绍及基本使用
学亮编程手记
03-10 258
包是一个设计用于处理并发任务中控制流和取消信号的核心库。它允许在多个函数和goroutine之间共享请求范围内的状态和取消信号，尤其是在服务器处理HTTP请求、数据库查询或其他涉及异步操作的地方。总结来说，Golang的Context是一个强大的工具，用于管理goroutine间的协作，尤其是取消逻辑和共享请求级别数据，有助于提升程序的健壮性和响应能力。在Go语言（Golang）中，
context.Context从主函数传递给异步函数出现context canceled是为啥？
最新发布
宋发元
07-11 308
通常情况下，如果在主函数中创建的被取消，那么传递给异步函数的上下文也会随之取消。这是因为在 Go 语言中，是一种用来控制和取消操作的机制，它是按照调用链传递的。具体来说，当你在主函数中创建一个，然后将它传递给一个异步函数时，如果主函数执行完毕（例如返回或者退出），那么创建的这个上下文可能会被取消。这意味着异步函数可能会收到一个取消信号，从而停止执行或者进行相应的清理工作。
go的context.WithTimeout学习
wangkai6666的博客
10-07 587
context WithTimeout
Go context.WithTimeout函数：超时控制
TCatTime的博客
01-16 9728
Go实现超时控制：context.WithTimeout函数介绍、使用示例。
go context之WithTimeout的使用
热门推荐
papaya的博客
07-11 3万+
代码如下 package main import ( "context" "fmt" "time" ) func main() { // 创建一个子节点的context,3秒后自动超时 ctx, cancel := context.WithTimeout(context.Background(), time.Second*3) go watch(ctx, "监控1") go watch(ctx, "监控2") fmt.Println("现在开始等待8秒,time=", time.
golang中context使用——WithTimeout和WithDeadline
archer的技术故事
12-07 5337
程序和上一篇的withCancel是类似的，只是创建子context的方式不同，这里使用的是withTimeout和WithDeadline的方式。 下面，上代码： package main import ( "context" "errors" "fmt" "time" ) var c = 1 func doSome(i int) error { c++ fmt.Prin...
Golang | 一文带你深入context
RoddeHope的博客
07-11 700
前言 首先解答上一篇文章一文带你快速入门context中留下的疑惑，为什么要defer cancelFunc()？ func main() { parent := context.Background() for i := 0; i < 100; i++ { go doRequest(parent) } time.Sleep(time.Second * 10) } // doRequest 模拟网络请求 func doRequest(parent co
GoLang之使用Context控制请求超时的实现
09-17
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) defer cancel() // 使用 ctx 来控制超时 select { case <-ctx.Done(): if ctx.Err() == context.DeadlineExceeded { ...
Golang学习笔记——context包
vvstormhao的博客
07-15 455
说明 Context上下文用于控制函数调用链，所有进入服务的请求需要创建Context，调用其他服务需要接受一个Context，Context需要在函数调用链中进行传播。 使用WithCancel,WithDeadline,WithTimeout,WithVaule，可以从一个Context上派生出子Context,并得到CancelFunc。调用CancelFunc可以关闭子Context及其派生出来的Context。 使用Context的程序需要遵循如下原则： 1.不要将Context存储在结构当中，
golang context WithTimeout 琐碎
zuoye1010的博客
04-11 333
运行的结果是：起始时间。。。。。。aa watch ctx2收到信号，监控退出,time2= 1712829564parent收到信号，监控退出,time= 1712829564起始时间。。。。。。aa watch ctx2收到信号，监控退出,time2= 1712829663parent收到信号，监控退出,time= 1712829663。
golang context.WithTimeout 超时处理
ylqmf的专栏
08-18 5347
package main import ( "golang.org/x/net/context" "log" "math/rand" "time" ) func test(is_first *bool, prev_map *map[string]string) { rand.Seed(int64(time.Now().Nanosecond()))
go context包的WithTimeout和WithCancel的使用
admin18511385056的博客
05-20 521
1、WaitGroup 　　它是一种控制并发的方式，它的这种方式是控制多个goroutine同时完成。 func main() { var wg sync.WaitGroup wg.Add(2) go func() { time.Sleep(2*time.Second) fmt.Println("1号完成") wg.Done() }() go...
#### golang context 的取消/超时等操作 ####
仅做个人笔记
12-03 2783
转自：https://segmentfault.com/a/1190000022484275 仅做个人备份，浏览请看原文 使用context实现取消功能 现在我们知道了应用程序为什么需要取消功能，接下来我们开始探究在Go中如何实现它。因为“取消事件”与正在执行的操作高度相关，因此很自然地会将它与上下文捆绑在一起。 取消功能需要从两方面实现才能完成： 监听取消事件 发出取消事件 监听取消事件 Go语言context标准库的Context类型提供了一个Done()方法，该方法返回一个类型为..
Golang深入浅出之-Go语言上下文（context）包：处理取消与超时
zevjay的博客
04-28 510
context包是Go语言并发编程中的重要工具，它帮助我们更好地管理并发操作，尤其是处理取消和超时场景。正确使用context可以显著提升应用的健壮性和响应性。记住，始终关注上下文的传递、正确处理取消信号、以及合理设置超时，这些都是避免常见问题的关键。通过上述示例和建议，希望你能更加深入地理解并有效利用context包，构建出更加稳定高效的Go应用程序。
golang源码阅读-context.WithTimeout
无
05-10 1502
context.WithTimeout 可用于一定时间关闭函数或调用，如调用超时，主动关闭调用 1.context.WithTimeout简单使用 func main() { ctx, _ := context.WithTimeout(context.Background(), 4*time.Second) printNum2(ctx) } func printNum2(ctx context.Context) { //要打印的数字 n := 0 for { select { ca
context.WithTimeout()之实现Gorm超时控制
AaronCao
09-02 2517
Context是Golang中的上下文，Gorm是当前用的比较多的SQL组件库，在Gorm中，Gorm通过提供了Context支持，在某种程度上来说，Gorm目前提供的Context可以实现对于SQL的超时控制。本意是为了实现gorm单条SQL语句执行时间的控制而引入的，限制单条语句执行时间，后面在修改过程中遇到了关于的问题，在修复问题的过程中让自己对有了更深的理解。
golang context的WithTimeout实现调用自定义函数超时处理
宁静致远的博客
12-04 949
context的WithTimeout实现调用自定义函数超时处理 func UploadContent(content, objectName string) chan error { errCh := make(chan error, 1) return errCh } func UploadFromString(content, objectName string) { ctx, cancel := context.WithTimeout(context.Background(), t
golang如何获取上下文的所有信息
06-13
在 Golang 中，可以通过 `context` 包来获取上下文的所有信息。`context` 包提供了一个 `Context` 接口，该接口定义了一组方法，用于获取和设置上下文信息。具体来说，可以通过 `context.Background()` 方法创建一个空的上下文，然后使用 `WithCancel`、`WithDeadline`、`WithTimeout` 或 `WithValue` 等方法来创建一个新的上下文，并在其中设置相应的信息。 例如，以下代码演示了如何创建一个具有超时时间的上下文，并在其中设置一个字符串值： ``` package main import ( "context" "fmt" "time" ) func doSomething(ctx context.Context) { // 获取上下文中的字符串值 value := ctx.Value("key").(string) fmt.Println("value:", value) // 等待上下文超时或被取消 select { case <-ctx.Done(): fmt.Println("context done:", ctx.Err()) case <-time.After(5 * time.Second): fmt.Println("done") } } func main() { // 创建一个具有超时时间的上下文，并设置一个字符串值 ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() ctx = context.WithValue(ctx, "key", "value") // 在新的 Goroutine 中执行任务 go doSomething(ctx) // 等待一段时间 time.Sleep(10 * time.Second) } ``` 在这个例子中，我们首先使用 `context.Background()` 方法创建了一个空的上下文，然后使用 `context.WithTimeout()` 方法创建了一个具有 3 秒超时时间的新上下文。接着，我们使用 `context.WithValue()` 方法在新上下文中设置了一个字符串值。最后，我们在新的 Goroutine 中执行了一个任务，并等待一段时间，以便让任务有足够的时间执行。在任务中，我们通过 `ctx.Value()` 方法获取了上下文中的字符串值，并使用 `select` 语句等待上下文超时或被取消。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值