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

小伙伴们对Golang编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《如何停止基于ticker重复运行的goRoutine》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

func main() {
    // Start a long-running process, capture stdout and stderr
    findCmd := cmd.NewCmd("find", "/", "--name", "needle")
    statusChan := findCmd.Start() // non-blocking

    ticker := time.NewTicker(2 * time.Second)

    // Print last line of stdout every 2s
    go func() {               ------------ this keeps running in background, how do I stop this goroutine
        for range ticker.C {
            status := findCmd.Status()
            n := len(status.Stdout)
            if len > 10 {
               findCmd.Stop()     ------- at this point I want to stop this goroutine
            }
            fmt.Println(status.Stdout[n-1])
        }
    }()

    // Stop command after 1 hour
    go func() {
        <-time.After(1 * time.Hour)
        findCmd.Stop()
    }()

    // Check if command is done
    select {
    case finalStatus := <-statusChan:
        // done
    default:
        // no, still running
    }

    // Block waiting for command to exit, be stopped, or be killed
    finalStatus := <-statusChan
}

goroutine 用于每 2 秒打印一次 stdout 的最后一行，尝试了一些方法来停止 goroutine，但没有任何效果。 如何使用通道停止该 goroutine

正确答案

这就是使用 select, case 的地方。你可以这样做：

ticker := time.newticker(2 * time.second)

done := make(chan struct{})
// the go routine that you want to stop when needed
go func() {
    select {
    case <-ticker.c:
        // do stuff
    case <-done:
        ticker.stop() // this is optional based on your purpose
    }
}()

// do stuff

// stop above go routine
close(done) // when there are many go routine you want to stop as reading from closed channel return the channel zero value
// or
done <- struct{}{}  // when there is only 1 go routine you want to stop

其中一个选项是将上下文传递给此类函数/特性。每当您传递上下文时，您都可以捕获取消信号并在选择语句中使用它。

func main() {
    appctx := context.background()

    // ...
    
    ticker := time.newticker(2 * time.second)
    tickerctx, tickercancel := context.withcancel(appctx) // create context for ticker, derive from root context

    // print last line of stdout every 2s
    go func(ctx context.context) {
        for {
            select {
            case <-ticker.c: // tick!
                // ...
                // if you need to perform any operation requiring the context pass `ctx`.
                // if case the ctx is canceled all operations should be terminated as well.
                
            case <-ctx.done() // context has been cancelled
                return
            }
        }
    }(tickerctx)

    // stop command after 1 hour
    go func() {
        <-time.after(1 * time.hour)
        tickercancel()
    }() 
    // ...
}

这样，我们就可以使用上下文，并且可以控制需要上下文的所有操作（我们可以随时取消它们）。

在您的情况下，可能还有另一个改进，在一段时间后终止基于 ctx 的操作（不需要使用另一个带有计时器的 goroutine）：

func main() {
    appCtx := context.Background()

    // ...
    
    ticker := time.NewTicker(2 * time.Second)
    tickerCtx, tickerCancel := context.WithTimeout(appCtx, time.Duration(1) * time.Hour) // create a context with a timeout

    // Print last line of stdout every 2s
    go func(ctx context.Context) {
        for {
            select {
            case <-ticker.C: // tick!
                // ...
            case <-ctx.Done() // context has been cancelled
                return
            }
        }
    }(tickerCtx)

    // We don't need to run a new goroutine terminate the ctx. The timeout we set will do the job. 
    // ...
}

终于介绍完啦！小伙伴们，这篇关于《如何停止基于ticker重复运行的goRoutine》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！