Use time.NewTicker in Go to implement a time-execution function. First, create a ticker and listen to its channel, and execute the objective function when a signal is received; second, put the ticker into the goroutine to avoid blocking the main thread; finally, combine select and interrupt signals to exit gracefully. The sample code triggers the doSomething function by listening to ticker.C for loop, and ensures resource release through defer ticker.Stop(); to avoid blocking the main program, put the ticker into the startTicker function and run in the goroutine; in addition, the program can be elegantly exited by listening to interrupt signals by select.

Implementing a ticker for executing functions in Go mainly depends on the Ticker type provided by the standard library time . You can use it to trigger an operation periodically, such as polling status, regularly cleaning caches, etc.

Here is a basic idea: create a ticker, then listen to its channel in a goroutine, and execute the objective function when the signal is received.

Create the basic ticker using time.NewTicker

Go's time.NewTicker returns a Ticker object with a channel and a timestamp is sent for each specified time interval. You can perform tasks by listening to this channel.

The sample code is as follows:

 package main

import (
    "fmt"
    "time"
)

func doSomething() {
    fmt.Println("A function was executed")
}

func main() {
    // Trigger every 2 seconds := time.NewTicker(2 * time.Second)
    defer ticker.Stop() // Stop ticker before the program exits to avoid resource leakage for range ticker.C {
        doSomething()
    }
}

This code will print "A function executed" every two seconds in the background. Note that we used defer ticker.Stop() to ensure that the resource is released when the program exits.

Run in goroutine to avoid blocking the main thread

In the example above, the for loop is blocking, so if you have other logic to execute, it is best to put it in a separate goroutine.

The modified code is as follows:

 package main

import (
    "fmt"
    "time"
)

func doSomething() {
    fmt.Println("Timed task is running...")
}

func startTicker() {
    ticker := time.NewTicker(3 * time.Second)
    defer ticker.Stop()

    for range ticker.C {
        doSomething()
    }
}

func main() {
    go startTicker()

    // The main thread continues to do other things or waits to exit fmt.Println("The main program is running, press Ctrl C to stop")
    time.Sleep(10 * time.Second) // Simulate the main program to run for a period of time}

In this way, your main program can continue to perform other tasks, and ticker runs silently in the background.

Optional: Use select to control the exit timing

Sometimes you may need to control the ticker's exit gracefully, such as stopping it when an interrupt signal (Ctrl C) is received. At this time, select can be used in combination with channel.

Example:

 package main

import (
    "fmt"
    "os"
    "os/signal"
    "time"
)

func doSomething() {
    fmt.Println("Working...")
}

func main() {
    ticker := time.NewTicker(2 * time.Second)
    defer ticker.Stop()

    stopChan := make(chan os.Signal, 1)
    signal.Notify(stopChan, os.Interrupt)

    for {
        select {
        case <-ticker.C:
            doSomething()
        case <-stopChan:
            fmt.Println("\nReceived an interrupt signal, ready to exit...")
            Return
        }
    }
}

This way you can exit the program cleanly with Ctrl C.

Basically that's it. ticker is a simple but very practical tool. Just be careful not to forget to call .Stop() and do a synchronization process in a concurrent environment.

The above is the detailed content of How do I create a ticker that executes a function repeatedly at a specified interval in Go?. For more information, please follow other related articles on the PHP Chinese website!