Go Academy · Lektion

Timer und Ticker

Arbeit planen und wiederholen

Timer und Ticker ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Mit Sleep pausieren

Das einfachste Werkzeug zur Ablaufsteuerung ist time.Sleep(d). Es pausiert die aktuelle Goroutine für eine bestimmte Zeitspanne.

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("start")
    time.Sleep(10 * time.Millisecond)
    fmt.Println("done")
}

Was ist ein Timer?

Ein time.Timer wird nach einer Verzögerung einmal ausgelöst. Bei Ablauf sendet er die aktuelle Zeit über seinen C-Kanal.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTimer(10 * time.Millisecond)
    <-t.C
    fmt.Println("timer fired")
}

Die Abkürzung time.After

time.After(d) gibt einen Kanal zurück, der nach der Verzögerung einen Wert liefert. Dies ist ein praktischer einmaliger Timer, für den keine Variable erforderlich ist.

package main

import (
    "fmt"
    "time"
)

func main() {
    <-time.After(10 * time.Millisecond)
    fmt.Println("elapsed")
}

Einen Timer stoppen

timer.Stop() bricht einen Timer ab, bevor er ausgelöst wird. Die Methode gibt true zurück, wenn der Timer rechtzeitig gestoppt wurde.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTimer(time.Hour)
    stopped := t.Stop()
    fmt.Println("stopped:", stopped)
}

Was ist ein Ticker?

Ein time.Ticker wird in einem festen Intervall wiederholt ausgelöst und sendet dabei jedes Mal über seinen C-Kanal.

Verwenden Sie ihn für regelmäßige Aufgaben wie Polling oder Animationsframes.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    <-ticker.C
    fmt.Println("tick")
    ticker.Stop()
}

Ticks zählen

Durchlaufen Sie den Ticker-Kanal, um auf jedes Intervall zu reagieren, und stoppen Sie ihn nach genügend Ticks.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    for i := 1; i <= 3; i++ {
        <-ticker.C
        fmt.Println("tick", i)
    }
    ticker.Stop()
}

Einen Ticker immer stoppen

Im Gegensatz zu einem Timer läuft ein Ticker weiter, bis Sie Stop() aufrufen. Wenn Sie ihn nicht stoppen, werden Ressourcen nicht freigegeben.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    defer ticker.Stop()
    <-ticker.C
    fmt.Println("one tick, will stop on return")
}

Komfortfunktion time.Tick

time.Tick(d) gibt direkt einen Ticker-Kanal zurück. Das ist einfach, aber der Ticker kann nicht gestoppt werden. Verwenden Sie diese Funktion daher nur für die gesamte Laufzeit des Programms.

package main

import (
    "fmt"
    "time"
)

func main() {
    c := time.Tick(5 * time.Millisecond)
    <-c
    fmt.Println("ticked")
}

Timeout mit select

Kombinieren Sie einen Arbeitskanal in einem select mit time.After, um ein Timeout zu implementieren.

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    go func() { done <- true }()
    select {
    case <-done:
        fmt.Println("work finished")
    case <-time.After(time.Second):
        fmt.Println("timed out")
    }
}

AfterFunc führt einen Callback aus

time.AfterFunc(d, f) führt die Funktion f nach der Verzögerung in einer eigenen Goroutine aus, ohne dass Sie einen Kanal auslesen müssen.

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    time.AfterFunc(10*time.Millisecond, func() {
        fmt.Println("callback ran")
        done <- true
    })
    <-done
}

Timer und Ticker

Wählen Sie je nachdem, ob eine Wiederholung erforderlich ist:

Timer: wird nach einer Verzögerung einmal ausgelöst.
Ticker: wird in einem Intervall immer wieder ausgelöst.
Stoppen Sie beide nach Abschluss, um Ressourcen freizugeben.

package main

import (
    "fmt"
    "time"
)

func main() {
    <-time.After(5 * time.Millisecond)
    fmt.Println("one-shot complete")
}

Kurze Überprüfung

Welcher Typ wird in einem festen Intervall wiederholt ausgelöst?

Zusammenfassung: Timer und Ticker

Sie haben gelernt, Aufgaben zeitlich zu planen:

Sleep pausiert, Timer und time.After werden einmal ausgelöst.
Ticker und time.Tick werden wiederholt ausgelöst.
Verwenden Sie Stop() zum Aufräumen und kombinieren Sie es mit select für Timeouts.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    defer ticker.Stop()
    for i := 0; i < 2; i++ {
        <-ticker.C
        fmt.Println("beat")
    }
}

Häufig gestellte Fragen

Ist die Lektion „Timer und Ticker“ kostenlos?

Ja — der vollständige Text von „Timer 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 „Timer und Ticker“?

Arbeit planen und wiederholen 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 3 von 4.

Wie lange dauert die Lektion „Timer 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

← Zurück zu Go Academy