go的context.WithTimeout运用

已于 2023-07-05 23:48:17 修改
阅读量888 收藏
点赞数
分类专栏： go 文章标签： golang
于 2023-07-05 23:05:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangkai6666/article/details/131563502
版权
本文详细探讨了Go语言中context.WithTimeout的使用，通过普通和奇怪示例展示了在不同场景下的行为。文章提出了在父环境和子环境设置不同超时时遇到的问题，并提供了多个解决方案，包括糟糕方案和有效方案，强调了主协程退出对子协程的影响。
摘要由CSDN通过智能技术生成

context.WithTimeout

看着简单，复杂环境下用着难

普通示例1

func Test_CancelTime(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(5))
	defer cancel()
	fmt.Println("main=>", time.Now())
	go worker()
	for range ctx.Done() {
		fmt.Println("main receive notice", time.Now())
		break
	}
	fmt.Println("main<=", time.Now()) // worker()超过了5s，但是依旧5s后退出
}

func worker() {
	fmt.Println("worker=>", time.Now())
	i := 0
	for {
		i++
		if i > 100000000 {
			fmt.Println("worker run", time.Now())
			i = 0
		}
	}
	fmt.Println("worker<=", time.Now())
}

普通示例2

func Test_CancelTime(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(5))
	defer cancel()
	fmt.Println("main=>", time.Now())
	go worker()
	for range ctx.Done() {
		fmt.Println("main receive notice", time.Now())
		break
	}
	fmt.Println("main<=", time.Now()) // worker()没有超过5s，但是依旧5s后退出
}

func worker() {
	fmt.Println("worker=>", time.Now())
	i := 0
	for {
		i++
		if i > 100 {
			break
		}
	}
	fmt.Println("worker<=", time.Now())
}

普通示例3

func Test_CancelTime(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(5))
	defer cancel()
	fmt.Println("main=>", time.Now())
	go worker()
	for range ctx.Done() {
		fmt.Println("main receive notice", time.Now())
		break
	}
	fmt.Println("main<=", time.Now()) // worker() sleep 10秒，但是依旧5s后退出
}

func worker() {
	fmt.Println("worker=>", time.Now())
	time.Sleep(time.Second * time.Duration(10))
	fmt.Println("worker<=", time.Now())
}

普通示例4

func Test_CancelTime(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(5))
	defer cancel()
	fmt.Println("main=>", time.Now())
	go worker()
	for range ctx.Done() {
		fmt.Println("main receive notice", time.Now())
		break
	}
	fmt.Println("main<=", time.Now()) // worker() sleep 2秒，但是依旧5s后退出
}

func worker() {
	fmt.Println("worker=>", time.Now())
	time.Sleep(time.Second * time.Duration(2))
	fmt.Println("worker<=", time.Now()) // worker() sleep 2秒，但是依旧5s后退出
}

奇怪示例1

Test_CancelTime函数5秒退出

func Test_CancelTime(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(5))
	defer cancel()
	fmt.Println("main=>", time.Now())
	go worker(ctx, 100)
	for range ctx.Done() {
		fmt.Println("main receive notice", time.Now())
		break
	}
	fmt.Println("main<=", time.Now())
}

func worker(ctx context.Context, n int) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(10))
	defer cancel()
	fmt.Println("worker=>", time.Now())
	go workInner(ctx, n)
	for range ctx.Done() {
		fmt.Println("worker receive notice", time.Now())
		break
	}
	fmt.Println("worker<=", time.Now())
}

func workInner(ctx context.Context, n int) {
	group, newCtx := errgroup.WithContext(ctx)
	group.SetLimit(3)
	for i := 0; i < n; i++ {
		curIndex := i
		group.Go(func() (err error) {
			defer func() {
				if e := recover(); e != nil {
					logs.CtxError(newCtx, "[workerInner] panic recovered: %v", string(debug.Stack()))
				}
			}()

			fmt.Printf("workerInner %v=>%v\n", curIndex, time.Now())
			time.Sleep(time.Second * time.Duration(2))
			fmt.Printf("workerInner %v<=%v\n", curIndex, time.Now())
			return nil
		})
	}

	if err := group.Wait(); err != nil {
		logs.CtxError(newCtx, "[workerInner] group failed, err=%v", err)
		return
	}
}

奇怪示例2

Test_CancelTime函数依旧是5秒退出

func Test_CancelTime(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(5))
	defer cancel()
	fmt.Println("main=>", time.Now())
	go worker(ctx, 100)
	for range ctx.Done() {
		fmt.Println("main receive notice", time.Now())
		break
	}
	fmt.Println("main<=", time.Now())
}

func worker(ctx context.Context, n int) {
	ctx, cancel := context.WithTimeout(ctx, time.Second*time.Duration(10))
	defer cancel()
	fmt.Println("worker=>", time.Now())
	go workInner(ctx, n)
	for range ctx.Done() {
		fmt.Println("worker receive notice", time.Now())
		break
	}
	fmt.Println("worker<=", time.Now())
}

func workInner(ctx context.Context, n int) {
	group, newCtx := errgroup.WithContext(ctx)
	group.SetLimit(3)
	for i := 0; i < n; i++ {
		curIndex := i
		group.Go(func() (err error) {
			defer func() {
				if e := recover(); e != nil {
					logs.CtxError(newCtx, "[workerInner] panic recovered: %v", string(debug.Stack()))
				}
			}()

			fmt.Printf("workerInner %v=>%v\n", curIndex, time.Now())
			time.Sleep(time.Second * time.Duration(2))
			fmt.Printf("workerInner %v<=%v\n", curIndex, time.Now())
			return nil
		})
	}

	if err := group.Wait(); err != nil {
		logs.CtxError(newCtx, "[workerInner] group failed, err=%v", err)
		return
	}
}

奇怪示例3

func Test_CancelTime(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(10))
	defer cancel()
	fmt.Println("main=>", time.Now())
	go worker(ctx, 100)
	for range ctx.Done() {
		fmt.Println("main receive notice", time.Now())
		break
	}
	fmt.Println("main<=", time.Now())
}

func worker(ctx context.Context, n int) {
	ctx, cancel := context.WithTimeout(ctx, time.Second*time.Duration(4))
	defer cancel()
	fmt.Println("worker=>", time.Now())
	go workInner(ctx, n)
	for range ctx.Done() {
		fmt.Println("worker receive notice", time.Now())
		break
	}
	fmt.Println("worker<=", time.Now())
}

func workInner(ctx context.Context, n int) {
	group, newCtx := errgroup.WithContext(ctx)
	group.SetLimit(3)
	for i := 0; i < n; i++ {
		curIndex := i
		group.Go(func() (err error) {
			defer func() {
				if e := recover(); e != nil {
					logs.CtxError(newCtx, "[workerInner] panic recovered: %v", string(debug.Stack()))
				}
			}()

			fmt.Printf("workerInner %v=>%v\n", curIndex, time.Now())
			time.Sleep(time.Second * time.Duration(2))
			fmt.Printf("workerInner %v<=%v\n", curIndex, time.Now())
			return nil
		})
	}

	if err := group.Wait(); err != nil {
		logs.CtxError(newCtx, "[workerInner] group failed, err=%v", err)
		return
	}
}

返回值

main=> 2023-07-05 20:48:34.792095 +0800 CST m=+2.173696454
worker=> 2023-07-05 20:48:34.792172 +0800 CST m=+2.173773493
workerInner 2=>2023-07-05 20:48:34.792234 +0800 CST m=+2.173835427
workerInner 1=>2023-07-05 20:48:34.792265 +0800 CST m=+2.173866728
workerInner 0=>2023-07-05 20:48:34.792269 +0800 CST m=+2.173870488
workerInner 1<=2023-07-05 20:48:36.792364 +0800 CST m=+4.173964493
workerInner 0<=2023-07-05 20:48:36.792383 +0800 CST m=+4.174001401
workerInner 3=>2023-07-05 20:48:36.792411 +0800 CST m=+4.174011412
workerInner 2<=2023-07-05 20:48:36.792446 +0800 CST m=+4.174046582
workerInner 4=>2023-07-05 20:48:36.792444 +0800 CST m=+4.174044861
workerInner 5=>
最低0.47元/天 解锁文章
~kiss~
关注
专栏目录
go协程控制——context
sHuXnHs
03-09 489
context 为什么有context 首先,如果我们在并发程序中,如果需要我们去通知子协程结束我们会怎么做? 我们可能会通过一个channel+select去通知,如下: package main import ( "fmt" "time" ) func main() { exitChan := make(chan bool) go func() { for { ...
GoLang之使用Context控制请求超时的实现
09-17
主要介绍了GoLang之使用Context控制请求超时的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
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.
go的context.WithTimeout学习
wangkai6666的博客
10-07 620
context WithTimeout
Go context.WithTimeout函数：超时控制
TCatTime的博客
01-16 9883
Go实现超时控制：context.WithTimeout函数介绍、使用示例。
golang context WithTimeout 琐碎
最新发布
zuoye1010的博客
04-11 372
运行的结果是：起始时间。。。。。。aa watch ctx2收到信号，监控退出,time2= 1712829564parent收到信号，监控退出,time= 1712829564起始时间。。。。。。aa watch ctx2收到信号，监控退出,time2= 1712829663parent收到信号，监控退出,time= 1712829663。
GOLANG使用Context实现传值、超时和取消的方法
09-19
ctx, cancel := context.WithTimeout(context.Background(), 3 * time.Second) defer cancel() pkt, err := stack.Read(ctx) if err != nil { if errors.Is(err, context.DeadlineExceeded) { fmt.Println("Read ...
Go八股文大全，面试宝典
03-03
这些问题涵盖了Go语言的基础语法、特性和高级用法，是考察程序员对Go语言理解深度的重要方面。以下将针对标题和描述中提到的知识点进行详细解释： 1. **flag库了解吗？有什么陷阱？** - flag库是Go标准库的一部分...
golang源码阅读-context.WithTimeout
无
05-10 1518
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
go 使用context 实现超时 取消
01-20
不适用 for 循环的话使用 注释部分select 在 select 中区分 取消和超时的操作 package main import ( bytes context fmt io os time ) func main() { var res = make(chan string) var cancelSignal = make(chan string) go func() { // 捕获 输入窗口的取消信号 signal := make([]byte, 1) signalBuffer := bytes.NewBuffer(signal)
context.WithTimeout()之实现Gorm超时控制
AaronCao
09-02 2736
Context是Golang中的上下文，Gorm是当前用的比较多的SQL组件库，在Gorm中，Gorm通过提供了Context支持，在某种程度上来说，Gorm目前提供的Context可以实现对于SQL的超时控制。本意是为了实现gorm单条SQL语句执行时间的控制而引入的，限制单条语句执行时间，后面在修改过程中遇到了关于的问题，在修复问题的过程中让自己对有了更深的理解。
关于golang的context.WithTimeout的cancel的说明
两只羊的博客
03-24 2万+
简介context是一个在go中时常用到的程序包，google官方开发。特别常见的一个应用场景是由一个请求衍生出的各个goroutine之间需要满足一定的约束关系，以实现一些诸如有效期，中止routine树，传递请求全局变量之类的功能。使用context实现上下文功能约定需要在你的方法的传入参数的第一个传入一个context.Context类型的变量。 比如: 上层需要指定超时的情况: ctx,
golang中context使用——WithTimeout和WithDeadline
archer的技术故事
12-07 5370
程序和上一篇的withCancel是类似的，只是创建子context的方式不同，这里使用的是withTimeout和WithDeadline的方式。 下面，上代码： package main import ( "context" "errors" "fmt" "time" ) var c = 1 func doSome(i int) error { c++ fmt.Prin...
go context包中WithTimeout和WithCancel的实战
weixin_42282999的博客
06-17 678
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 func() { time.Sleep(2*time.Second
go context包的WithTimeout和WithCancel的使用
admin18511385056的博客
05-20 531
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的WithTimeout实现调用自定义函数超时处理
宁静致远的博客
12-04 962
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 context 超时控制
wwhhff11
05-03 1万+
https://www.ddhigh.com/2019/01/02/golang-timeout-context.html
go context包的WithTimeout和WithCancel的使用
bob的博客
05-13 586
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 func() { time.Sleep(2*time.Second
context.withtimeout
04-11
"context.withtimeout"是Python中的一个函数，在使用它时可以指定一个超时时间，在超时时间内尝试执行某个操作，如果超时则会抛出TimeoutError异常。这个函数常用于控制程序执行时间或线程阻塞时间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值