Go Academy · Lekcja

Timery i tickery

Planuj i powtarzaj pracę

Timery i tickery to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 3 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.

Wstrzymywanie za pomocą Sleep

Najprostszym narzędziem do planowania jest time.Sleep(d), które wstrzymuje bieżącą goroutine na określony czas.

package main

import (
    "fmt"
    "time"
)

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

Czym jest timer?

Obiekt time.Timer uruchamia się raz po upływie opóźnienia. Po wygaśnięciu wysyła bieżący czas do swojego kanału C.

package main

import (
    "fmt"
    "time"
)

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

Skrót time.After

time.After(d) zwraca kanał, który dostarcza jedną wartość po upływie opóźnienia. Jest to wygodny jednorazowy timer, który nie wymaga zmiennej.

package main

import (
    "fmt"
    "time"
)

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

Zatrzymywanie timera

timer.Stop() anuluje timer przed jego uruchomieniem. Zwraca true, jeśli udało się zatrzymać timer na czas.

package main

import (
    "fmt"
    "time"
)

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

Czym jest ticker?

Obiekt time.Ticker uruchamia się wielokrotnie w stałych odstępach, za każdym razem wysyłając wartość do swojego kanału C.

Należy go używać do zadań wykonywanych okresowo, takich jak odpytywanie lub generowanie klatek animacji.

package main

import (
    "fmt"
    "time"
)

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

Zliczanie sygnałów

Należy iterować po kanale tickera, aby reagować na każdy odstęp, a następnie zatrzymać ticker po odebraniu wystarczającej liczby sygnałów.

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

Ticker należy zawsze zatrzymywać

W przeciwieństwie do timerów ticker działa do chwili wywołania Stop(). Pominięcie zatrzymania powoduje wyciek zasobów.

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

Wygoda time.Tick

time.Tick(d) zwraca bezpośrednio kanał tickera. Jest to proste rozwiązanie, którego nie można zatrzymać, dlatego należy go używać tylko wtedy, gdy ma działać przez cały czas życia programu.

package main

import (
    "fmt"
    "time"
)

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

Limit czasu za pomocą select

Aby zaimplementować limit czasu, należy połączyć kanał roboczy z time.After w instrukcji select.

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 uruchamia funkcję zwrotną

time.AfterFunc(d, f) uruchamia funkcję f we własnej goroutine po upływie opóźnienia, bez konieczności odczytywania kanału.

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 a ticker

Wyboru należy dokonać na podstawie częstotliwości powtarzania:

Timer: uruchamia się raz po upływie opóźnienia.
Ticker: uruchamia się wielokrotnie w stałych odstępach.
Po zakończeniu należy zatrzymać oba, aby zwolnić zasoby.

package main

import (
    "fmt"
    "time"
)

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

Szybkie sprawdzenie

Jaki typ uruchamia się wielokrotnie w stałych odstępach?

Podsumowanie: timery i tickery

Poznano sposoby planowania zadań:

Sleep wstrzymuje działanie, a Timer i time.After uruchamiają się raz.
Ticker i time.Tick uruchamiają się wielokrotnie.
Do sprzątania należy używać Stop(), a do obsługi limitów czasu — łączyć je z select.

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

Często zadawane pytania

Czy lekcja „Timery i tickery” jest bezpłatna?

Tak — pełny tekst „Timery i tickery” 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 „Timery i tickery”?

Planuj i powtarzaj pracę Ć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 3 z 4.

Ile czasu zajmuje lekcja „Timery i tickery”?

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