goroutine没有看到上下文取消吗？

huangapple
go评论153阅读模式
英文:

goroutine not seeing context cancel?

问题

我有两个 goroutine 同时运行。

在某个时刻，我希望程序能够优雅地退出，所以我使用 cancel() 函数通知我的 goroutine 需要停止，但只有其中一个接收到了消息。

这是我的主函数（简化版）：

  1. ctx := context.Background()
  2. ctx, cancel := context.WithCancel(ctx)
  4. done := make(chan os.Signal, 1)
  5. signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
  7. wg := &sync.WaitGroup{}
  8. wg.Add(2)
  10. go func() {
  11.     err := eng.Watcher(ctx, wg)
  12.     if err != nil {
  13.         cancel()
  14.     }
  15. }()
  17. go func() {
  18.     err := eng.Suspender(ctx, wg)
  19.     if err != nil {
  20.         cancel()
  21.     }
  22. }()
  24. <-done // 等待 SIGINT / SIGTERM
  25. log.Print("接收到关闭信号")
  26. cancel()
  27. wg.Wait()
  29. log.Print("控制器正常退出")

Suspender goroutine 成功退出（以下是代码）：

  1. package main
  3. import (
  4.     "context"
  5.     "sync"
  6.     "time"
  8.     log "github.com/sirupsen/logrus"
  9.     metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  10.     "k8s.io/client-go/util/retry"
  11. )
  13. func (eng *Engine) Suspender(ctx context.Context, wg *sync.WaitGroup) error {
  15.     contextLogger := eng.logger.WithFields(log.Fields{
  16.         "go-routine": "Suspender",
  17.     })
  18.     contextLogger.Info("启动 Suspender goroutine")
  19.     now := time.Now().In(eng.loc)
  21.     for {
  22.         select {
  23.         case n := <-eng.Wl:
  24.             // 做一些事情
  27.         case <-ctx.Done():
  28.             // 上下文结束，停止处理结果
  29.             contextLogger.Infof("goroutine Suspender 被上下文取消")
  30.             return nil
  31.         }
  32.     }
  34. }

以下是没有接收到上下文取消的函数：

  1. package main
  3. import (
  4.     "context"
  5.     "sync"
  6.     "time"
  8.     log "github.com/sirupsen/logrus"
  9. )
  11. func (eng *Engine) Watcher(ctx context.Context, wg *sync.WaitGroup) error {
  12.     contextLogger := eng.logger.WithFields(log.Fields{
  13.         "go-routine":      "Watcher",
  14.         "uptime-schedule": eng.upTimeSchedule,
  15.     })
  16.     contextLogger.Info("启动 Watcher goroutine")
  18.     ticker := time.NewTicker(time.Second * 30)
  19.     for {
  20.         select {
  21.         case <-ctx.Done():
  22.             contextLogger.Infof("goroutine watcher 被上下文取消")
  23.             log.Printf("toto")
  24.             return nil
  25.         case <-ticker.C:
  27.             // 做一些事情
  28.         }
  29.     }
  30. }

请问我能帮到你什么？谢谢 goroutine没有看到上下文取消吗？

英文:

I have two goroutines running at the same time.

At some point, I want my program to exit gracefully so I use the cancel() func to notify my goroutines that they need to be stopped, but only one of the two receive the message.

here is my main (simplified):

  1. ctx := context.Background()
  2. ctx, cancel := context.WithCancel(ctx)
  4. done := make(chan os.Signal, 1)
  5. signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
  7. wg := &amp;sync.WaitGroup{}
  8. wg.Add(2)
  10. go func() {
  11. 	err := eng.Watcher(ctx, wg)
  12. 	if err != nil {
  13. 		cancel()
  14. 	}
  15. }()
  17. go func() {
  18. 	err := eng.Suspender(ctx, wg)
  19. 	if err != nil {
  20. 		cancel()
  21. 	}
  22. }()
  24. &lt;-done // wait for SIGINT / SIGTERM
  25. log.Print(&quot;receive shutdown&quot;)
  26. cancel()
  27. wg.Wait()
  29. log.Print(&quot;controller exited properly&quot;)

The Suspender goroutine exist successfully (here is the code):

  1. package main
  3. import (
  4. 	&quot;context&quot;
  5. 	&quot;sync&quot;
  6. 	&quot;time&quot;
  8. 	log &quot;github.com/sirupsen/logrus&quot;
  9. 	metav1 &quot;k8s.io/apimachinery/pkg/apis/meta/v1&quot;
  10. 	&quot;k8s.io/client-go/util/retry&quot;
  11. )
  13. func (eng *Engine) Suspender(ctx context.Context, wg *sync.WaitGroup) error {
  15. 	contextLogger := eng.logger.WithFields(log.Fields{
  16. 		&quot;go-routine&quot;: &quot;Suspender&quot;,
  17. 	})
  18. 	contextLogger.Info(&quot;starting Suspender goroutine&quot;)
  19. 	now := time.Now().In(eng.loc)
  21. 	for {
  22. 		select {
  23. 		case n := &lt;-eng.Wl:
  24. 			//dostuff
  27. 		case &lt;-ctx.Done():
  28. 			// The context is over, stop processing results
  29. 			contextLogger.Infof(&quot;goroutine Suspender canceled by context&quot;)
  30. 			return nil
  31. 		}
  32. 	}
  34. }

and here is the func that is not receiving the context cancellation:

  1. package main
  3. import (
  4. 	&quot;context&quot;
  5. 	&quot;sync&quot;
  6. 	&quot;time&quot;
  8. 	log &quot;github.com/sirupsen/logrus&quot;
  9. )
  11. func (eng *Engine) Watcher(ctx context.Context, wg *sync.WaitGroup) error {
  12. 	contextLogger := eng.logger.WithFields(log.Fields{
  13. 		&quot;go-routine&quot;:      &quot;Watcher&quot;,
  14. 		&quot;uptime-schedule&quot;: eng.upTimeSchedule,
  15. 	})
  16. 	contextLogger.Info(&quot;starting Watcher goroutine&quot;)
  18. 	ticker := time.NewTicker(time.Second * 30)
  19. 	for {
  20. 		select {
  21. 		case &lt;-ctx.Done():
  22. 			contextLogger.Infof(&quot;goroutine watcher canceled by context&quot;)
  23. 			log.Printf(&quot;toto&quot;)
  24. 			return nil
  25. 		case &lt;-ticker.C:
  26. 			
  27. 				//dostuff
  28. 			}
  29. 		}
  30. 	}
  31. }

Can you please help me ?

Thanks goroutine没有看到上下文取消吗？

答案1

得分: 2

你尝试过使用errgroup吗？它内置了上下文取消功能：

  1. ctx := context.Background()
  2. ctx, cancel := context.WithCancel(ctx)
  3. defer cancel()
  5. done := make(chan os.Signal, 1)
  6. signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
  8. // "golang.org/x/sync/errgroup"
  9. wg, ctx := errgroup.WithContext(ctx)
  11. wg.Go(func() error {
  12. 	return eng.Watcher(ctx, wg)
  13. })
  15. wg.Go(func() error {
  16. 	return eng.Suspender(ctx, wg)
  17. })
  19. wg.Go(func() error {
  20. 	defer cancel()
  21. 	<-done
  22. 	return nil
  23. })
  25. err := wg.Wait()
  26. if err != nil {
  27. 	log.Print(err)
  28. }
  30. log.Print("receive shutdown")
  31. log.Print("controller exited properly")
英文:

Did you try it with an errgroup? It has context cancellation baked in:

  1. ctx := context.Background()
  2. ctx, cancel := context.WithCancel(ctx)
  3. defer cancel()
  5. done := make(chan os.Signal, 1)
  6. signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
  8. // &quot;golang.org/x/sync/errgroup&quot;
  9. wg, ctx := errgroup.WithContext(ctx)
  11. wg.Go(func() error {
  12. 	return eng.Watcher(ctx, wg)
  13. })
  15. wg.Go(func() error {
  16. 	return eng.Suspender(ctx, wg)
  17. })
  19. wg.Go(func() error {
  20. 	defer cancel()
  21. 	&lt;-done
  22. 	return nil
  23. })
  25. err := wg.Wait()
  26. if err != nil {
  27. 	log.Print(err)
  28. }
  30. log.Print(&quot;receive shutdown&quot;)
  31. log.Print(&quot;controller exited properly&quot;)

答案2

得分: 0

表面上看，代码看起来不错。我唯一能想到的是在"dostuff"中可能很繁忙。在调试器中逐步执行与时间相关的代码可能会很棘手，所以尝试添加一些日志记录：

  1.   case <-ticker.C:
  2.      log.Println("doing stuff")
  3.      //dostuff
  4.      log.Println("done stuff")

（我还假设你在go协程中的某个地方调用了wg.Done()，尽管如果缺少这些调用，那也不会导致你所描述的问题。）

英文:

On the surface the code looks good. The only thing I can think is that it's busy in "dostuff". It can be tricky to step through timing related code in the debugger so try adding some logging:

  1.   case &lt;-ticker.C:
  2.      log.Println(&quot;doing stuff&quot;)
  3.      //dostuff
  4.      log.Println(&quot;done stuff&quot;)

(I also assume you are calling wg.Done() in your go-routines somewhere though if they are missing that would not be the cause of the problem you describe.)

答案3

得分: 0

Suspender和Watcher中的代码没有通过Done()方法调用来减少waitgroup计数器 - 这是无限执行的原因。

老实说，忘记这样的小事情是相当正常的。这就是为什么作为Go的标准通用实践，建议使用defer并在函数/方法的最开始处理那些关键的事情。

更新后的实现可能如下所示：

  1. func (eng *Engine) Suspender(ctx context.Context, wg *sync.WaitGroup) error {
  2.     defer wg.Done()
  4. // ------------------------------------
  6. func (eng *Engine) Watcher(ctx context.Context, wg *sync.WaitGroup) error {
  7.     defer wg.Done()
  8.     contextLogger := eng.logger.WithFields(log.Fields{

另外，另一个建议是，查看主例程时，建议始终将context按值传递给任何被调用的go例程或方法调用（lambda）。
这种方法可以帮助开发人员避免很难注意到的与程序相关的错误。

  1. go func(ctx context.Context) {
  2.     err := eng.Watcher(ctx, wg)
  3.     if err != nil {
  4.         cancel()
  5.     }
  6. }(ctx)

编辑-1：（确切的解决方案）

尝试按我之前提到的方式使用值传递来传递上下文。否则，两个go例程将使用相同的上下文（因为您正在引用它），并且只会触发一个ctx.Done()。
通过将ctx作为值传递，Go中创建了两个独立的子上下文。在使用cancel()关闭父上下文时，两个子上下文都会独立触发ctx.Done()。

英文:

The code in Suspender and in Watcher doesn't decrement the waitgroup counter through the Done() method call - the reason behind the infinite execution.

And to be honest it's quite normal to forget such small things. That's why as a standard general practice in Go, it is suggested to use defer and handle things that are critical (and should be handled inside the function/method ) at the very beginning.

The updated implementation might look like

  1. func (eng *Engine) Suspender(ctx context.Context, wg *sync.WaitGroup) error {
  2.     defer wg.Done()
  4. // ------------------------------------
  6. func (eng *Engine) Watcher(ctx context.Context, wg *sync.WaitGroup) error {
  7.     defer wg.Done()
  8.     contextLogger := eng.logger.WithFields(log.Fields{

Also, another suggestion, looking at the main routine, it is always suggested to pass context by value to any go-routine or method calls (lambda) that are being invoked.
This approach saves developers from a lot of program-related bugs that can't be noticed very easily.

  1. go func(ctx context.Context) {
  2.     err := eng.Watcher(ctx, wg)
  3.     if err != nil {
  4.         cancel()
  5.     }
  6. }(ctx)

Edit-1: (the exact solution)

Try passing the context using the value in the go routines as I mentioned earlier. Otherwise, both of the go routine will use a single context (because you are referencing it) and only one ctx.Done() will be fired.
By passing ctx as a value 2 separate child contexts are created in Go. And while closing parent with cancel() - both children independently fires ctx.Done().

huangapple
  • 本文由 发表于 2022年6月12日 00:40:49
  • 转载请务必保留本文链接：https://go.coder-hub.com/72586157.html
  • go
  • goroutine
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定