Go Academy · Lekcja

Limity czasu i tickery

Używanie time.After i time.Tick wraz z select

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

Dlaczego limity czasu mają znaczenie

Bez limitów czasu gorutyna oczekująca na wolny kanał może blokować się w nieskończoność. Pakiet time udostępnia mechanizmy dodawania sterowania opartego na czasie do operacji na kanałach.

time.After dla jednorazowego limitu czasu

time.After(d) zwraca kanał, z którego można odebrać wartość po upływie czasu trwania d. Należy użyć go jako przypadku select, aby przerwać oczekiwanie.

select {
case res := <-ch:
    fmt.Println(res)
case <-time.After(2 * time.Second):
    fmt.Println("timed out")
}

Powtarzające się limity czasu z time.NewTimer

W przypadku timerów wielokrotnego użytku należy użyć time.NewTimer i wywołać Reset po każdym użyciu. Należy wywołać Stop, aby zapobiec wyciekowi gorutyny timera.

timer := time.NewTimer(5 * time.Second)
defer timer.Stop()
select {
case <-timer.C:
    fmt.Println("timer fired")
}

time.Tick a time.NewTicker

time.Tick jest wygodny, ale powoduje wyciek bazowego tickera — należy preferować time.NewTicker, aby można było wywołać Stop() i zwolnić zasoby.

ticker := time.NewTicker(500 * time.Millisecond)
defer ticker.Stop()
for range ticker.C {
    fmt.Println("tick")
}

Ticker w pętli

Połączenie tickera z kanałem done pozwala wykonywać pracę okresową i prawidłowo ją zatrzymać.

ticker := time.NewTicker(time.Second)
done := make(chan struct{})
go func() {
    for {
        select {
        case <-ticker.C:
            doWork()
        case <-done:
            ticker.Stop()
            return
        }
    }
}()

Wyciek związany z time.After

time.After tworzy nowy timer przy każdym wywołaniu, a timer nie może zostać usunięty przez garbage collector, dopóki nie zadziała. W ciasnej pętli należy użyć time.NewTimer + Reset, aby uniknąć wycieku timerów.

Termin a limit czasu

Limit czasu to względny czas trwania („czekaj 5 s”). Termin to czas bezwzględny („czekaj do 14:00”). Należy użyć time.Until(deadline), aby przekształcić termin w czas trwania dla time.After.

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 jest zalecany

W przypadku procedur obsługi HTTP i uporządkowanych zadań należy preferować context.WithTimeout zamiast surowych limitów czasu opartych na kanałach — automatycznie propaguje on anulowanie w całym stosie wywołań.

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

Ograniczanie częstotliwości za pomocą Ticker

Ticker jest najprostszym ogranicznikiem częstotliwości: wysyła jedno żądanie na każde tyknięcie. Aby obsługiwać serie żądań, należy wstępnie wypełnić buforowany kanał i uzupełniać go za pomocą tickera.

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

Zegar monotoniczny

Czasy trwania używane przez timery Go korzystają z zegara monotonicznego, a nie zegara ściennego, dzięki czemu są odporne na zmiany zegara systemowego. time.Since i time.Until również z niego korzystają.

Prawidłowe zatrzymywanie tickera

Po wywołaniu ticker.Stop() kanał tickera NIE jest zamykany — po prostu przestaje otrzymywać wartości. W razie potrzeby przed zakończeniem należy opróżnić kanał z oczekującej wartości.

Szybkie sprawdzenie

Dlaczego time.NewTicker jest preferowany zamiast time.Tick?

Podsumowanie: limity czasu i tickery

Najważniejsze informacje:

time.After służy do jednorazowego limitu czasu w select
time.NewTicker służy do powtarzającej się pracy; zawsze należy wywołać Stop()
Należy unikać time.After w pętlach — powoduje wycieki timerów
W przypadku pracy, którą można anulować, należy preferować context.WithTimeout

Często zadawane pytania

Czy lekcja „Limity czasu i tickery” jest bezpłatna?

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

Używanie time.After i time.Tick wraz z select Ć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 2 z 4.

Ile czasu zajmuje lekcja „Limity czasu 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