10 Timer und Ticker

In diesem Kapitel werden wir uns mit der Verwendung von Timern und Ticker beschäftigen, um zeitgesteuerte Aufgaben in Go zu handhaben. Diese Mechanismen sind sehr nützlich, wenn es darum geht, bestimmte Aktionen zu verzögern oder in regelmäßigen Abständen auszuführen.

10.1 Timer

Ein Timer in Go ist ein Mechanismus, der nach einer bestimmten Zeitdauer ein Ereignis auslöst. Timer sind Teil des time-Pakets.

10.1.1 Verwendung eines Timers

Hier ein einfaches Beispiel für die Verwendung eines Timers:

package main

import (
    "fmt"
    "time"
)

func main() {
    timer := time.NewTimer(2 * time.Second)

    fmt.Println("Timer started")
    <-timer.C
    fmt.Println("Timer expired")
}

In diesem Beispiel:

  1. Wir erstellen einen Timer, der nach zwei Sekunden abläuft, indem wir time.NewTimer(2 * time.Second) aufrufen.
  2. Wir drucken “Timer started” aus, um anzuzeigen, dass der Timer gestartet wurde.
  3. Wir warten darauf, dass der Timer abläuft, indem wir auf timer.C lauschen, was ein Channel ist, der ein Signal sendet, wenn der Timer abläuft.
  4. Sobald der Timer abläuft, drucken wir “Timer expired” aus.

10.1.2 Reset und Stop eines Timers

Ein Timer kann auch zurückgesetzt oder gestoppt werden:

package main

import (
    "fmt"
    "time"
)

func main() {
    timer := time.NewTimer(5 * time.Second)
    go func() {
        time.Sleep(2 * time.Second)
        if timer.Stop() {
            fmt.Println("Timer stopped")
        }
    }()
    fmt.Println("Waiting for timer...")
    <-timer.C
    fmt.Println("Timer expired")
}

In diesem Beispiel:

  1. Wir erstellen einen Timer, der nach fünf Sekunden abläuft.
  2. In einer separaten Goroutine warten wir zwei Sekunden und versuchen dann, den Timer zu stoppen. Wenn das Stoppen erfolgreich ist, drucken wir “Timer stopped”.
  3. Wir warten weiterhin darauf, dass der Timer abläuft. Wenn der Timer gestoppt wurde, wird der Channel timer.C nie ein Signal senden.

10.2 Ticker

Ein Ticker in Go ist ein Mechanismus, der in regelmäßigen Abständen ein Ereignis auslöst. Ticker sind ebenfalls Teil des time-Pakets.

10.2.1 Verwendung eines Tickers

Hier ein einfaches Beispiel für die Verwendung eines Tickers:

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(1 * time.Second)
    done := make(chan bool)

    go func() {
        time.Sleep(5 * time.Second)
        ticker.Stop()
        done <- true
    }()

    for {
        select {
        case <-done:
            fmt.Println("Ticker stopped")
            return
        case t := <-ticker.C:
            fmt.Println("Tick at", t)
        }
    }
}

In diesem Beispiel:

  1. Wir erstellen einen Ticker, der jede Sekunde ein Ereignis auslöst, indem wir time.NewTicker(1 * time.Second) aufrufen.
  2. In einer separaten Goroutine warten wir fünf Sekunden und stoppen dann den Ticker. Außerdem senden wir ein Signal an den done-Channel, um anzuzeigen, dass der Ticker gestoppt wurde.
  3. In einer Schleife verwenden wir ein select-Statement, um entweder auf das Stoppsignal (done) oder das Ticker-Signal (ticker.C) zu warten.
  4. Jedes Mal, wenn der Ticker ein Signal sendet, drucken wir “Tick at” gefolgt von der aktuellen Zeit aus. Wenn der Ticker gestoppt wird, drucken wir “Ticker stopped” aus und beenden die Schleife.

10.2.2 Verwendung von Ticker und Timer zusammen

Manchmal ist es nützlich, Timer und Ticker zusammen zu verwenden. Hier ein Beispiel:

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(1 * time.Second)
    timer := time.NewTimer(5 * time.Second)

    for {
        select {
        case t := <-ticker.C:
            fmt.Println("Tick at", t)
        case <-timer.C:
            fmt.Println("Timer expired, stopping ticker")
            ticker.Stop()
            return
        }
    }
}

In diesem Beispiel:

  1. Wir erstellen einen Ticker, der jede Sekunde ein Ereignis auslöst.
  2. Wir erstellen einen Timer, der nach fünf Sekunden abläuft.
  3. In einer Schleife verwenden wir ein select-Statement, um entweder auf das Ticker-Signal oder das Timer-Signal zu warten.
  4. Jedes Mal, wenn der Ticker ein Signal sendet, drucken wir “Tick at” gefolgt von der aktuellen Zeit aus. Wenn der Timer abläuft, drucken wir “Timer expired, stopping ticker” aus, stoppen den Ticker und beenden die Schleife.