如何停止基于ticker重复运行的goRoutine？

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

How to stop goRoutine which repeatedly runs based on ticker

问题

  1. func main() {
  2. 	// 启动一个长时间运行的进程，捕获 stdout 和 stderr
  3. 	findCmd := cmd.NewCmd("find", "/", "--name", "needle")
  4. 	statusChan := findCmd.Start() // 非阻塞
  6. 	ticker := time.NewTicker(2 * time.Second)
  8. 	// 每 2 秒打印 stdout 的最后一行
  9. 	go func() { // 这个 goroutine 在后台一直运行，我该如何停止它？
  10. 		for range ticker.C {
  11. 			status := findCmd.Status()
  12. 			n := len(status.Stdout)
  13. 			if n > 10 {
  14. 				findCmd.Stop() // 在这一点上，我想停止这个 goroutine
  15. 			}
  16. 			fmt.Println(status.Stdout[n-1])
  17. 		}
  18. 	}()
  20. 	// 1 小时后停止命令
  21. 	go func() {
  22. 		<-time.After(1 * time.Hour)
  23. 		findCmd.Stop()
  24. 	}()
  26. 	// 检查命令是否完成
  27. 	select {
  28. 	case finalStatus := <-statusChan:
  29. 		// 完成
  30. 	default:
  31. 		// 否，仍在运行
  32. 	}
  34. 	// 阻塞等待命令退出、停止或被杀死
  35. 	finalStatus := <-statusChan
  36. }

使用 goroutine 来每 2 秒打印 stdout 的最后一行，尝试了几种方法来停止 goroutine，但都没有成功。如何使用通道来停止这个 goroutine？

英文: 
  1. func main() {
  2. 	// Start a long-running process, capture stdout and stderr
  3. 	findCmd := cmd.NewCmd(&quot;find&quot;, &quot;/&quot;, &quot;--name&quot;, &quot;needle&quot;)
  4. 	statusChan := findCmd.Start() // non-blocking
  6. 	ticker := time.NewTicker(2 * time.Second)
  8. 	// Print last line of stdout every 2s
  9. 	go func() {               ------------ this keeps running in background, how do I stop this goroutine
  10. 		for range ticker.C {
  11. 			status := findCmd.Status()
  12. 			n := len(status.Stdout)
  13.             if len &gt; 10 {
  14.                findCmd.Stop()     ------- at this point I want to stop this goroutine
  15.             }
  16. 			fmt.Println(status.Stdout[n-1])
  17. 		}
  18. 	}()
  20. 	// Stop command after 1 hour
  21. 	go func() {
  22. 		&lt;-time.After(1 * time.Hour)
  23. 		findCmd.Stop()
  24. 	}()
  26. 	// Check if command is done
  27. 	select {
  28. 	case finalStatus := &lt;-statusChan:
  29. 		// done
  30. 	default:
  31. 		// no, still running
  32. 	}
  34. 	// Block waiting for command to exit, be stopped, or be killed
  35. 	finalStatus := &lt;-statusChan
  36. }

Goroutine is used to print last line of stdout every 2s, tried few things to stop the goroutine but none worked.
How can I stop that goroutine using channels

答案1

得分: 2

这是使用select和case的示例。你可以像这样做：

  1. ticker := time.NewTicker(2 * time.Second)
  3. done := make(chan struct{})
  4. // 当需要停止的goroutine
  5. go func() {
  6. 	select {
  7. 	case <-ticker.C:
  8. 		// 做一些事情
  9. 	case <-done:
  10. 		ticker.Stop() // 根据你的目的，这是可选的
  11. 	}
  12. }()
  14. // 做一些事情
  16. // 停止上面的goroutine
  17. close(done) // 当有多个你想要停止的goroutine时，读取已关闭的通道会返回通道的零值
  18. // 或者
  19. done <- struct{}{}  // 当只有一个你想要停止的goroutine时
英文:

This is where select, case is used. You can do something like this:

  1. ticker := time.NewTicker(2 * time.Second)
  3. done := make(chan struct{})
  4. // The go routine that you want to stop when needed
  5. go func() {
  6. 	select {
  7. 	case &lt;-ticker.C:
  8. 		// do stuff
  9. 	case &lt;-done:
  10. 		ticker.Stop() // this is optional based on your purpose
  11. 	}
  12. }()
  14. // do stuff
  16. // stop above go routine
  17. close(done) // when there are many go routine you want to stop as reading from closed channel return the channel zero value
  18. // OR
  19. done &lt;- struct{}{}  // when there is only 1 go routine you want to stop

答案2

得分: 0

其中一个选项是将上下文传递给这样的函数/特性。每当你传递一个上下文，你可以捕捉到取消信号，并在选择语句中使用它。

  1. func main() {
  2.     appCtx := context.Background()
  4.     // ...
  5.     
  6.     ticker := time.NewTicker(2 * time.Second)
  7.     tickerCtx, tickerCancel := context.WithCancel(appCtx) // 为ticker创建上下文，派生自根上下文
  9.     // 每2秒打印stdout的最后一行
  10.     go func(ctx context.Context) {
  11.         for {
  12.             select {
  13.             case <-ticker.C: // tick!
  14.                 // ...
  15.                 // 如果你需要执行任何需要上下文的操作，请传递`ctx`。
  16.                 // 如果上下文被取消，所有操作也应该被终止。
  17.                 
  18.             case <-ctx.Done() // 上下文已取消
  19.                 return
  20.             }
  21.         }
  22.     }(tickerCtx)
  24.     // 1小时后停止命令
  25.     go func() {
  26.         <-time.After(1 * time.Hour)
  27.         tickerCancel()
  28.     }() 
  29.     // ...
  30. }

所以，通过这种方式我们使用了上下文，并且我们对所有需要上下文的操作都有控制权（我们可以随时取消它们）。

在你的情况下，还可以进行另一种改进，即在一段时间后终止基于上下文的操作（无需使用另一个带有定时器的goroutine）：

  1. func main() {
  2.     appCtx := context.Background()
  4.     // ...
  5.     
  6.     ticker := time.NewTicker(2 * time.Second)
  7.     tickerCtx, tickerCancel := context.WithTimeout(appCtx, time.Duration(1) * time.Hour) // 创建带有超时的上下文
  9.     // 每2秒打印stdout的最后一行
  10.     go func(ctx context.Context) {
  11.         for {
  12.             select {
  13.             case <-ticker.C: // tick!
  14.                 // ...
  15.             case <-ctx.Done() // 上下文已取消
  16.                 return
  17.             }
  18.         }
  19.     }(tickerCtx)
  21.     // 我们不需要运行一个新的goroutine来终止上下文。我们设置的超时会完成这个工作。
  22.     // ...
  23. }
英文:

One of the options is to pass the context to such a function/feature. Whenever you pass a context you can catch the cancel signal and use it in the select statements.

  1. func main() {
  2.     appCtx := context.Background()
  4.     // ...
  5.     
  6.     ticker := time.NewTicker(2 * time.Second)
  7.     tickerCtx, tickerCancel := context.WithCancel(appCtx) // create context for ticker, derive from root context
  9.     // Print last line of stdout every 2s
  10.     go func(ctx context.Context) {
  11.         for {
  12.             select {
  13.             case &lt;-ticker.C: // tick!
  14.                 // ...
  15.                 // if you need to perform any operation requiring the context pass `ctx`.
  16.                 // If case the ctx is canceled all operations should be terminated as well.
  17.                 
  18.             case &lt;-ctx.Done() // context has been cancelled
  19.                 return
  20.             }
  21.         }
  22.     }(tickerCtx)
  24.     // Stop command after 1 hour
  25.     go func() {
  26.         &lt;-time.After(1 * time.Hour)
  27.         tickerCancel()
  28.     }() 
  29.     // ...
  30. }

So, this way we are using context, and we have control over all operations where a context is needed (we can cancel them at any time).

In your case there could be another improvement, to terminate the ctx-based operation after some time (without the need to use another goroutine with a timer):

  1. func main() {
  2.     appCtx := context.Background()
  4.     // ...
  5.     
  6.     ticker := time.NewTicker(2 * time.Second)
  7.     tickerCtx, tickerCancel := context.WithTimeout(appCtx, time.Duration(1) * time.Hour) // create a context with a timeout
  9.     // Print last line of stdout every 2s
  10.     go func(ctx context.Context) {
  11.         for {
  12.             select {
  13.             case &lt;-ticker.C: // tick!
  14.                 // ...
  15.             case &lt;-ctx.Done() // context has been cancelled
  16.                 return
  17.             }
  18.         }
  19.     }(tickerCtx)
  21.     // We don&#39;t need to run a new goroutine terminate the ctx. The timeout we set will do the job. 
  22.     // ...
  23. }

huangapple
  • 本文由 发表于 2022年8月26日 19:30:28
  • 转载请务必保留本文链接：https://go.coder-hub.com/73500365.html
  • go
  • goroutine
匿名

发表评论

匿名网友

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

确定