Timer in Golang (Timer)

Timer In Golang Timer



Zeit ist alles in unserem täglichen Leben, aber noch wichtiger ist es, wenn es um die Programmierung wie das Planen von Aufgaben, das Implementieren von Zeitüberschreitungen, das Erstellen gleichzeitiger Anwendungen und mehr geht.

In Go verfügen wir über Timer, die es uns ermöglichen, Arbeiten mit Zeiten effizient zu erstellen. Timer werden vom Paket „time“ bereitgestellt.







In diesem Tutorial bringen wir Ihnen alles bei, was Sie über Timer in Go wissen müssen. Wir lernen Dinge wie Timer, die allgemeine Verwendung von Timern und dann die detaillierten Implementierungen von Timern.



Golang-Timer

Timer sind zeitbasierte Ereignisse, die zu einem vordefinierten Zeitpunkt in der Zukunft eine bestimmte Aktion auslösen. Betrachten Sie es als eine Möglichkeit, eine zukünftige Veranstaltung zu organisieren.



Timer spielen eine grundlegende Rolle bei der Abwicklung zeitbezogener Vorgänge in Go-Anwendungen.





Timer sind für verschiedene Zwecke nützlich, z. B. zum Planen von Aufgaben, zum Implementieren von Zeitüberschreitungen und zum Synchronisieren gleichzeitiger Vorgänge.

Verwendungsmöglichkeiten von Timern



Zu den häufigsten Anwendungsfällen von Timern in Go gehören die folgenden:

  • Aufgaben planen – Mit Timern können wir die Aufgaben planen, die zu einer bestimmten Zeit oder in verschiedenen Intervallen ausgeführt werden können.
  • Timeouts implementieren – Wenn Sie die Zeitlimits für einen bestimmten Vorgang durchsetzen müssen, sind Timer wahrscheinlich die beste Wahl. Sie können beispielsweise einen Timer verwenden, um eine Aufgabe abzubrechen, wenn deren Abschluss zu lange dauert.
  • Ratenbegrenzung – Wir können auch Timer verwenden, um die Geschwindigkeit zu steuern, mit der eine bestimmte Aktion oder Anforderung ausgeführt werden darf.
  • Gleichzeitige Synchronisierung – Timer können dabei helfen, die gleichzeitigen Vorgänge zu koordinieren und zu synchronisieren.

Nachdem das erledigt ist, lasst uns in die Materie der Timer in Go eintauchen.

Erstellen Sie einen Timer in Golang

In Go können wir einen Timer mit der Methode NewTimer() aus dem Paket „time“ erstellen. Die Funktion akzeptiert eine Dauer als Parameter, wie in der folgenden Syntax dargestellt:

Paket main
importieren (
„fmt“
'Zeit'
)
Funktion main ( ) {
timer := time.NewTimer ( 2 * Zeit.Sekunde )
fmt.Println ( „Warten, bis der Timer abgelaufen ist …“ )
< -timer.C
fmt.Println ( „Timer abgelaufen!“ )
}

In diesem Beispiel erstellen wir einen Timer, der nach 2 Sekunden abläuft. Anschließend warten wir mit „<- timer.C“ auf den Ablauf.

Der Typ „Timer“ repräsentiert ein einzelnes Ereignis. Wenn der Timer abläuft, wird die aktuelle Zeit an C gesendet, es sei denn, der Timer wurde von AfterFunc erstellt.

Setzen Sie einen Timer in Golang zurück

Go unterstützt die Möglichkeit, einen Timer zurückzusetzen, damit er nach einer bestimmten Dauer erneut zu zählen beginnt. Dies ist unglaublich nützlich, wenn Sie einen Timer wiederverwenden müssen, ohne ihn tatsächlich zu duplizieren.

Ein Beispiel ist wie folgt:

Paket main
importieren (
„fmt“
'Zeit'
)
Funktion main ( ) {
timer := time.NewTimer ( 2 * Zeit.Sekunde )
Timer.Reset ( 1 * Zeit.Sekunde )
fmt.Println ( „Warten, bis der Timer abgelaufen ist …“ )
< -timer.C
fmt.Println ( „Timer abgelaufen!“ )
}

Dadurch sollte der Timer nach einer Sekunde zurückgesetzt werden, wie in der Methode timer.Reset() definiert.

Stoppen Sie einen Timer in Golang

Wir können einen Timer stoppen, bevor er abläuft, indem wir die Methode Timer.Stop() aufrufen. Dadurch wird verhindert, dass der Timer die zugehörige Aktion auslöst.

Ein Beispielcode lautet wie folgt:

Paket main
importieren (
„fmt“
'Zeit'
)
Funktion main ( ) {
timer := time.NewTimer ( 5 * Zeit.Sekunde )

gestoppt := timer.Stop ( )
Wenn gestoppt {
fmt.Println ( „Timer gestoppt, bevor er abgelaufen ist“ )
} anders {
fmt.Println ( „Timer bereits abgelaufen oder gestoppt“ )
}
}

Dadurch sollte der Timer nach einer Sekunde gestoppt werden. Dies bedeutet, dass der 5-Sekunden-Timer vor der Beendigung nicht abläuft.

Verwenden einer Select-Anweisung mit Timern

Eine der leistungsstärksten und nützlichsten Operationen von Timern in Go besteht darin, sie mit der Go-Anweisung „select“ zu koppeln. Dies hilft, mehrere Kanäle, einschließlich Timer, gleichzeitig zu verwalten.

HINWEIS: In Go besteht die Rolle der „select“-Anweisung darin, es uns zu ermöglichen, auf mehrere Kanalvorgänge zu warten und Maßnahmen basierend auf dem ersten Kanal zu ergreifen, der bereit wird.

Wir können Timer mit der „select“-Anweisung verwenden, wie im folgenden Beispiel gezeigt:

Paket main
importieren (
„fmt“
'Zeit'
)
Funktion main ( ) {
Zeitüberschreitung := time.NewTimer ( 5 * Zeit.Sekunde )
gehen func ( ) {
Zeit.Schlaf ( 2 * Zeit.Sekunde )
} ( )
wählen {
Fall < -timeout.C:
fmt.Println ( 'Zeit abgelaufen für Vorgang' )
Fall < -Zeit danach ( 4 * Zeit.Sekunde ) :
fmt.Println ( „Fallback: Operation hat zu lange gedauert“ )
}
}

In diesem Beispiel erstellen wir einen Timer mit einem Timeout von fünf Sekunden. Anschließend verwenden wir die „select“-Anweisung, um entweder den Timeout- oder einen Fallback-Fall zu behandeln.

Periodische Timer mit Ticker

Das nächste, was sich gut mit Timern kombinieren lässt, sind Ticker. Mit Tickern können wir mithilfe des time.Ticker eine Aktion in festgelegten Abständen wiederholt ausführen.

Sie können sich Ticker wie einen Timer vorstellen, der nach jedem Ablauf automatisch zurückgesetzt wird.

Paket main
importieren (
„fmt“
'Zeit'
)
Funktion main ( ) {
ticker := time.NewTicker ( 1 * Zeit.Sekunde )
// Aufgabe wiederholen
gehen func ( ) {
für {
< -ticker.C
fmt.Println ( 'Tick!' )
}
} ( )
// laufen für 5 Sekunden
Zeit.Schlaf ( 5 * Zeit.Sekunde )

// Stoppen Sie den Ticker
ticker.Stopp ( )
fmt.Println ( „Ticker gestoppt“ )
}

Im gegebenen Beispiel definieren wir zunächst eine Aufgabe, die wir in bestimmten Abständen wiederholen möchten.

Anschließend erstellen wir einen neuen Ticker, der jede Sekunde tickt, und führen die vorherige Aufgabe aus. Wir hören dann auf, die Methode ticker.Stop() zu verwenden.

Das Ausführen des vorherigen Codes gibt eine Beispielausgabe wie folgt zurück:

Tick !
Tick !
Tick !
Tick !
Der Ticker wurde gestoppt

Abschluss

In diesem Tutorial haben wir mithilfe des „time“-Pakets viel über Timer in Go erfahren. Wir begannen mit den Grundlagen zum Erstellen, Zurücksetzen und Stoppen der Timer. Anschließend lernten wir die Verwendung von Timern mit den „select“-Anweisungen und lernten Ticker kennen.