英文:
Is there a way to cancel a context after a delay after one goroutine returns?
问题
问题
现状
我目前有一个 gin 处理函数,它在三个独立的 goroutine 中使用相同的上下文运行三个单独的查询。有一个错误组("golang.org/x/sync/errgroup"
)使用这个共享的上下文,处理程序在返回之前等待错误组。
目标
我试图实现的行为是,在其中一个 goroutine 完成后,剩余的 goroutine 应该强制执行超时,但如果 gin 请求被取消(连接关闭),则还应该取消这个上下文,这意味着需要使用 gin 的 ctx.Request.Context()
。
潜在解决方案
当前实现
目前,我有一个带有超时的上下文传递给了一个错误组,但这只是对所有 goroutine 强制执行超时。
timeoutCtx := context.WithTimeout(context.Background(), 10*time.Second)
g, err := errgroup.WithContext(timeoutCtx)
g.Go(func1)
g.Go(func2)
g.Go(func3)
err = g.Wait()
使用 gin 请求上下文是必需的,这样如果连接关闭并且请求被取消,goroutine 也会停止。
// ctx *gin.Context
g, err := errgroup.WithContext(ctx.Request.Context())
g.Go(func1)
g.Go(func2)
g.Go(func3)
err = g.Wait()
使用通道实现超时
package main
import (
"fmt"
"time"
)
func main() {
c1 := make(chan string, 1)
go func() {
time.Sleep(2 * time.Second)
c1 <- "result 1"
}()
select {
case res := <-c1:
fmt.Println(res)
case <-time.After(1 * time.Second):
fmt.Println("timeout 1")
}
c2 := make(chan string, 1)
go func() {
time.Sleep(2 * time.Second)
c2 <- "result 2"
}()
select {
case res := <-c2:
fmt.Println(res)
case <-time.After(3 * time.Second):
fmt.Println("timeout 2")
}
}
结合通道和请求上下文
这个解决方案接近但不够优雅或完整。
cQueryDone := make(chan bool)
g, err := errgroup.WithContext(ctx.Request.Context())
g.Go(func1)
g.Go(func2)
g.Go(func3)
// 假设 func1 func2 和 func3 都有 cQueryDone <- true
if <-cQueryDone {
select {
case <-cQueryDone:
select {
case <-cQueryDone:
// ctx.JSON
// return
case <-time.After(1*time.Second):
// ctx.JSON
// return
}
case <-time.After(3*time.Second):
// ctx.JSON
// return
}
}
err = g.Wait()
有没有更好、更符合 Go 语言习惯的方法来实现这个行为?
英文:
Problem
Situation
I currently have a gin handler function that runs three separate queries in three separate goroutines using the same context. There is an err group ("golang.org/x/sync/errgroup"
) that uses this shared context and the handler waits for the err group before returning.
Objective
The behavior I am trying to implement is after one of the goroutines finishes, there should be a timeout enforced on the remaining goroutines, but also this context should also be cancelled if the gin request is cancelled (connection closed), meaning gin's ctx.Request.Context()
would have to be used.
Potential Solutions
Current implementation
Currently, I have a context with timeout passed to an errgroup but this just enforces a timeout for all the goroutines.
timeoutCtx := context.WithTimeout(context.Background(), 10*time.Second)
g, err := errgroup.WithContext(timeoutCtx)
g.Go(func1)
g.Go(func2)
g.Go(func3)
err = g.Wait()
Using the gin request context is required so that if the connection is closed and the request is cancelled, the goroutines will also stop.
// ctx *gin.Context
g, err := errgroup.WithContext(ctx.Request.Context())
g.Go(func1)
g.Go(func2)
g.Go(func3)
err = g.Wait()
Using a channel to implement timeout
package main
import (
"fmt"
"time"
)
func main() {
c1 := make(chan string, 1)
go func() {
time.Sleep(2 * time.Second)
c1 <- "result 1"
}()
select {
case res := <-c1:
fmt.Println(res)
case <-time.After(1 * time.Second):
fmt.Println("timeout 1")
}
c2 := make(chan string, 1)
go func() {
time.Sleep(2 * time.Second)
c2 <- "result 2"
}()
select {
case res := <-c2:
fmt.Println(res)
case <-time.After(3 * time.Second):
fmt.Println("timeout 2")
}
}
Combining channels and request context
This solution is close but not very elegant or complete.
cQueryDone := make(chan bool)
g, err := errgroup.WithContext(ctx.Request.Context())
g.Go(func1)
g.Go(func2)
g.Go(func3)
// assumes func1 func2 and func3 all have cQueryDone <- true
if <-cQueryDone {
select {
case <-cQueryDone:
select {
case <-cQueryDone:
// ctx.JSON
// return
case <-time.After(1*time.Second):
// ctx.JSON
// return
}
case <-time.After(3*time.Second):
// ctx.JSON
// return
}
}
err = g.Wait()
Is there a better and more idiomatic way to implement this behavior in Go?
答案1
得分: 2
请注意 context.WithTimeout()
:
- 可以包装任何上下文(不仅限于
context.Background()
) - 还会返回一个
cancel
函数
你可以在 ctx.Request.Context()
上添加超时,并在任何查询完成时调用 cancel
:
timeoutCtx, cancel := context.WithTimeout(ctx.Request.Context())
g, err := errgroup.WithContext(timeoutCtx)
g.Go(func1(cancel)) // 将 cancel 回调传递给每个查询
g.Go(func2(cancel)) // 你可能还想传递 timeoutCtx
g.Go(func3(cancel))
g.Wait()
根据你的评论:还有 context.WithCancel()
,你可以在延迟后调用 cancel
childCtx, cancel := context.WithCancel(ctx.Request.Context())
g, err := errgroup.WithContext(childCtx)
hammerTime := func(){
<-time.After(1*time.Second)
cancel()
}
g.Go(func1(hammerTime)) // funcXX 应该能够访问 hammerTime
g.Go(func2(hammerTime))
g.Go(func3(hammerTime))
g.Wait()
英文:
Note that context.WithTimeout()
:
- can wrap any context (not just
context.Background()
) - also returns a
cancel
function
You can add a timeout on top of ctx.Request.Context()
, and call cancel
when any of the queries completes :
timeoutCtx, cancel := context.WithTimeout(ctx.Request.Context())
g, err := errgroup.WithContext(timeoutCtx)
g.Go( func1(cancel) ) // pass the cancel callback to each query some way or another
g.Go( func2(cancel) ) // you prabably want to also pass timeoutCtx
g.Go( func3(cancel) )
g.Wait()
Following your comment : there is also context.WithCancel()
, and you can call cancel after a delay
childCtx, cancel := context.WithCancel(ctx.Request.Context())
g, err := errgroup.WithContext(childCtx)
hammerTime := func(){
<-time.After(1*time.Second)
cancel()
}
g.Go( func1(hammerTime) ) // funcXX should have access to hammerTime
g.Go( func2(hammerTime) )
g.Go( func3(hammerTime) )
g.Wait()
通过集体智慧和协作来改善编程学习和解决问题的方式。致力于成为全球开发者共同参与的知识库,让每个人都能够通过互相帮助和分享经验来进步。
评论