Go Academy · Lektion

Zeitbasierte Planung

Regelmäßige Aufgaben ausführen

Zeitbasierte Planung ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Arbeiten nach Zeitplan ausführen

Viele Systeme benötigen regelmäßige Aufgaben: temporäre Dateien jede Nacht bereinigen, jeden Morgen eine Zusammenfassungs-E-Mail senden oder jede Minute eine API abfragen. Diese Lektion führt in die zeitbasierte Planung mit der Go-Standardbibliothek ein.

Das time-Paket

Gos time-Paket bildet die Grundlage. Wichtige Werkzeuge sind:

time.Sleep pausiert eine Goroutine
time.After gibt einen Kanal zurück, der einmalig auslöst
time.Ticker löst wiederholt aus
time.Timer löst nach einer Verzögerung einmalig aus

Eine naive Schleife

Der einfachste Scheduler: Aufgabe ausführen, schlafen, wiederholen.

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        fmt.Println("tick", i)
        time.Sleep(10 * time.Millisecond)
    }
}

Warum Sleep driftet

Eine Sleep-Schleife driftet: Wenn die Aufgabe 200 ms dauert und Sie 1 s schlafen, beträgt das tatsächliche Intervall 1,2 s, und die Abweichung summiert sich. Für genaue Intervalle verwenden Sie einen Ticker, der in einer späteren Lektion behandelt wird.

time.After für einmalige Verzögerungen

time.After(d) gibt einen Kanal zurück, der nach der Dauer d einmalig einen Wert empfängt. Das ist in select-Anweisungen für Timeouts nützlich.

select {
case <-time.After(2 * time.Second):
    fmt.Println("2s elapsed")
}

time.Timer

Ein Timer löst einmalig aus und kann angehalten oder zurückgesetzt werden. Das ist bei time.After nicht möglich, da es nicht abgebrochen werden kann.

t := time.NewTimer(5 * time.Second)
defer t.Stop()
<-t.C
fmt.Println("fired")

Zu einer bestimmten Zeit planen

Um eine Aufgabe beispielsweise um 3 Uhr morgens auszuführen, berechnen Sie die Dauer bis zu diesem Zeitpunkt und verwenden Sie dafür Sleep oder einen Timer. Planen Sie anschließend den nächsten Tag.

now := time.Now()
next := time.Date(now.Year(), now.Month(), now.Day(), 3, 0, 0, 0, now.Location())
if next.Before(now) {
    next = next.Add(24 * time.Hour)
}
fmt.Println("sleep for", time.Until(next))

Dauern sind typisiert

time.Duration ist ein int64-Wert in Nanosekunden und bietet praktische Konstanten wie time.Second, time.Minute und time.Hour. Multiplizieren Sie diese für gut lesbare Intervalle.

every := 30 * time.Minute
fmt.Println(every)

Monotone Zeit und Wanduhrzeit

Gos time.Now enthält eine monotone Zeitmessung, die zum Messen verstrichener Zeit verwendet wird und von Uhrenkorrekturen unbeeinflusst bleibt. Verwenden Sie für Zeitspannen time.Since statt die Zeitstempel der Wanduhr voneinander abzuziehen.

start := time.Now()
// ... work ...
fmt.Println("took", time.Since(start))

Wann Sie eine Bibliothek verwenden sollten

Bei komplexen Zeitplänen („jeden Wochentag um 9:15 Uhr“) ist die eigene Berechnung von Zeitwerten fehleranfällig. Die im nächsten Abschnitt behandelte Bibliothek robfig/cron analysiert Cron-Ausdrücke für Sie.

Ausführbar: Nächsten Lauf berechnen

Dieses eigenständige Programm berechnet ausschließlich mit dem time-Paket, wie lange es bis zur nächsten Minutengrenze dauert.

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Date(2026, 1, 1, 10, 30, 45, 0, time.UTC)
    nextMinute := now.Truncate(time.Minute).Add(time.Minute)
    fmt.Println("now:", now.Format("15:04:05"))
    fmt.Println("next run:", nextMinute.Format("15:04:05"))
    fmt.Println("wait:", nextMinute.Sub(now))
}

Kurztest

Testen Sie Ihr Verständnis der zeitbasierten Planung.

Zusammenfassung

Sie haben die Grundlagen der zeitbasierten Planung gelernt:

Das time-Paket stellt Sleep, After, Timer und Ticker bereit
Sleep-Schleifen driften; Ticker halten den Zeitplan ein
Berechnen Sie mit time.Until die Dauer bis zu einem Zielzeitpunkt
Verwenden Sie time.Since und die monotone Uhr zur Messung verstrichener Zeit

Häufig gestellte Fragen

Ist die Lektion „Zeitbasierte Planung“ kostenlos?

Ja — der vollständige Text von „Zeitbasierte Planung“ 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 „Zeitbasierte Planung“?

Regelmäßige Aufgaben ausführen 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 1 von 4.

Wie lange dauert die Lektion „Zeitbasierte Planung“?

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