Go Academy · Lekcja

Planowanie oparte na czasie

Wykonuj zadania okresowo

Planowanie oparte na czasie to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Uruchamianie zadań zgodnie z harmonogramem

Wiele systemów wymaga pracy wykonywanej okresowo: nocnego czyszczenia plików tymczasowych, wysyłania co rano wiadomości e-mail z podsumowaniem lub odpytywania interfejsu API co minutę. W tej lekcji przedstawiono planowanie oparte na czasie w języku Go z użyciem biblioteki standardowej.

Pakiet time

Pakiet time języka Go stanowi podstawę. Najważniejsze narzędzia:

time.Sleep wstrzymuje goroutine
time.After zwraca kanał, który aktywuje się jednokrotnie
time.Ticker aktywuje się wielokrotnie
time.Timer aktywuje się jednokrotnie po opóźnieniu

Naiwna pętla

Najprostszy harmonogramator: wykonaj pracę, uśpij działanie, powtórz.

package main

import (
    "fmt"
    "time"
)

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

Dlaczego sleep powoduje przesunięcia

Pętla z usypianiem stopniowo się rozjeżdża: jeśli praca trwa 200 ms, a następnie następuje uśpienie na 1 s, rzeczywisty odstęp wynosi 1,2 s i różnica się kumuluje. Aby uzyskać dokładne odstępy, należy użyć obiektu Ticker, który zostanie omówiony w dalszej lekcji.

time.After dla jednorazowych opóźnień

time.After(d) zwraca kanał, który po czasie trwania d jednokrotnie odbiera wartość. Jest przydatny w konstrukcji select do obsługi limitów czasu.

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

time.Timer

Obiekt Timer aktywuje się jednokrotnie i można go zatrzymać lub zresetować, w przeciwieństwie do time.After, którego nie można anulować.

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

Planowanie na określoną godzinę

Aby uruchomić zadanie na przykład o 3:00, należy obliczyć czas do tego momentu, odczekać go za pomocą sleep lub timera, a następnie zaplanować zadanie ponownie na następny dzień.

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))

Czasy trwania mają określony typ

time.Duration to wartość int64 wyrażająca nanosekundy, wyposażona w wygodne stałe: time.Second, time.Minute, time.Hour. Należy je mnożyć, aby czytelnie zapisywać odstępy czasu.

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

Zegar monotoniczny a zegar ścienny

Wartość zwracana przez time.Now zawiera odczyt zegara monotonicznego używany do mierzenia upływu czasu, odporny na korekty zegara. Do obliczania czasów trwania należy używać time.Since, a nie odejmowania wskazań zegara ściennego.

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

Kiedy sięgnąć po bibliotekę

W przypadku złożonych harmonogramów ("w każdy dzień roboczy o 9:15") samodzielne obliczenia czasu są podatne na błędy. Biblioteka robfig/cron, omawiana w następnej lekcji, analizuje za Państwa wyrażenia cron.

Wykonywalny przykład: obliczanie następnego uruchomienia

Ten samodzielny program oblicza czas pozostały do rozpoczęcia następnej minuty, korzystając wyłącznie z pakietu time.

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))
}

Szybkie sprawdzenie

Proszę sprawdzić swoją wiedzę o planowaniu opartym na czasie.

Podsumowanie

Opanowali Państwo podstawy planowania opartego na czasie:

pakiet time udostępnia funkcje Sleep, After, Timer i Ticker
pętle z użyciem Sleep stopniowo się rozjeżdżają, a tickery zachowują harmonogram
czas trwania do określonego momentu można obliczyć za pomocą time.Until
do pomiaru upływu czasu należy używać time.Since i zegara monotonicznego

Często zadawane pytania

Czy lekcja „Planowanie oparte na czasie” jest bezpłatna?

Tak — pełny tekst „Planowanie oparte na czasie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Planowanie oparte na czasie”?

Wykonuj zadania okresowo Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Planowanie oparte na czasie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy