Timeouts und Ticker
time.After und time.Tick mit select verwenden
Timeouts und Ticker ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum Timeouts wichtig sind
Ohne Timeouts kann eine Goroutine, die auf einen langsamen Kanal wartet, für immer blockieren. Das Paket time stellt grundlegende Funktionen bereit, um zeitbasierte Steuerung zu Kanaloperationen hinzuzufügen.
time.After für ein einmaliges Timeout
time.After(d) liefert einen Kanal, von dem nach der Dauer d ein Wert empfangen wird. Verwenden Sie ihn in einem select-Fall, um eine Warteoperation abzubrechen.
select {
case res := <-ch:
fmt.Println(res)
case <-time.After(2 * time.Second):
fmt.Println("timed out")
}Wiederholte Timeouts mit time.NewTimer
Verwenden Sie für wiederverwendbare Timer time.NewTimer und rufen Sie nach jeder Verwendung Reset auf. Rufen Sie Stop auf, um ein Durchsickern der Timer-Goroutine zu verhindern.
timer := time.NewTimer(5 * time.Second)
defer timer.Stop()
select {
case <-timer.C:
fmt.Println("timer fired")
}time.Tick im Vergleich zu time.NewTicker
time.Tick ist praktisch, führt aber zu einem Leak des zugrunde liegenden Tickers – bevorzugen Sie time.NewTicker, damit Sie mit Stop() Ressourcen freigeben können.
ticker := time.NewTicker(500 * time.Millisecond)
defer ticker.Stop()
for range ticker.C {
fmt.Println("tick")
}Ticker in einer Schleife
Kombinieren Sie einen Ticker mit einem done-Kanal, um regelmäßige Arbeit auszuführen und sauber zu beenden.
ticker := time.NewTicker(time.Second)
done := make(chan struct{})
go func() {
for {
select {
case <-ticker.C:
doWork()
case <-done:
ticker.Stop()
return
}
}
}()Leak durch time.After
time.After erstellt bei jedem Aufruf einen neuen Timer, der erst nach seinem Auslösen durch die Garbage Collection freigegeben werden kann. Verwenden Sie in einer engen Schleife time.NewTimer + Reset, um ein Timer-Leak zu vermeiden.
Deadline im Vergleich zu Timeout
Ein Timeout ist eine relative Dauer („5 Sekunden warten“). Eine Deadline ist ein absoluter Zeitpunkt („bis 14:00 Uhr warten“). Verwenden Sie time.Until(deadline), um eine Deadline für time.After in eine Dauer umzuwandeln.
deadline := time.Now().Add(5 * time.Second)
select {
case v := <-ch:
use(v)
case <-time.After(time.Until(deadline)):
fmt.Println("deadline exceeded")
}context.WithTimeout wird bevorzugt
Bevorzugen Sie bei HTTP-Handlern und strukturierten Abläufen context.WithTimeout gegenüber rohen Kanal-Timeouts – dadurch wird der Abbruch automatisch durch den Aufrufstapel weitergegeben.
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()Ratenbegrenzung mit Ticker
Ein Ticker ist der einfachste Ratenbegrenzer: Senden Sie pro Tick eine Anfrage. Für Burst-Unterstützung füllen Sie einen gepufferten Kanal vorab und füllen ihn mit einem Ticker wieder auf.
requests := make(chan int, 5)
for i := 0; i < 5; i++ { requests <- i }
close(requests)
limiter := time.NewTicker(200 * time.Millisecond)
for req := range requests {
<-limiter.C
fmt.Println("request", req)
}Monotone Uhr
Go verwendet für Timer-Dauern die monotone Uhr und nicht die Wanduhr, sodass sie gegen Anpassungen der Systemzeit immun sind. Auch time.Since und time.Until verwenden sie.
Ticker korrekt stoppen
Nach ticker.Stop() wird der Ticker-Kanal NICHT geschlossen – er empfängt lediglich keine weiteren Werte. Leeren Sie bei Bedarf vor der Rückkehr einen noch ausstehenden Wert aus dem Kanal.
Kurze Überprüfung
Warum wird time.NewTicker gegenüber time.Tick bevorzugt?
Zusammenfassung: Timeouts und Ticker
Wichtige Punkte:
- time.After für ein einmaliges Timeout in select
- time.NewTicker für wiederkehrende Arbeit; rufen Sie immer Stop() auf
- Vermeiden Sie time.After in Schleifen – es führt zu Timer-Leaks
- Bevorzugen Sie context.WithTimeout für abbrechbare Arbeit
Lerne Go mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 51
- Lektionen
- 203
Häufig gestellte Fragen
Ist die Lektion „Timeouts und Ticker“ kostenlos?
Ja — der vollständige Text von „Timeouts und Ticker“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Timeouts und Ticker“?
time.After und time.Tick mit select verwenden Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Go Academy zu starten?
Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Timeouts und Ticker“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?
Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Die select-Anweisung
- Timeouts und Ticker
- Fan-in- und Fan-out-Patterns
- Worker-Pool-Pattern