Go Academy · Oppitunti

Töiden hallittu alasajo

Pysäytä työt siististi

Oppitunti 4/413 vaihetta

Töiden hallittu alasajo on ilmainen Go Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Go Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Go Academy-kurssilla on yhteensä 4 oppituntia.

Tehtävien hallittu pysäyttäminen

Kesken tehtävän lopetettu ajastin voi vioittaa tietoja tai jättää työn puolivalmiiksi. Hallittu sammutus tarkoittaa, että uusia suorituksia ei enää hyväksytä, käynnissä olevien tehtävien annetaan valmistua määräaikaan asti ja ohjelma lopetetaan sen jälkeen.

Signaalien kuunteleminen

Siepatkaa käyttöjärjestelmän signaalit, kuten SIGINT (Ctrl+C) ja SIGTERM (orkestroijan pysäytyssignaali), jotta voitte aloittaa hallitun sammutuksen.

sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
<-sig
fmt.Println("shutting down")

signal.NotifyContext

Go 1.16 ja uudemmat versiot tarjoavat siistin apufunktion, joka peruuttaa kontekstin signaalin saapuessa.

ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
defer stop()
<-ctx.Done()

Ajastimen pysäyttäminen

robfig/cron-kirjastossa c.Stop() palauttaa kontekstin, joka valmistuu, kun kaikki käynnissä olevat tehtävät ovat päättyneet. Odottakaa sitä, jotta tehtävät ehtivät valmistua.

ctx := c.Stop()        // stops scheduling, returns ctx
<-ctx.Done()            // wait for running jobs
fmt.Println("all jobs finished")

Peruutuksen välittäminen tehtäville

Välittäkää konteksti jokaiselle tehtävälle, jotta pitkäkestoinen työ voi keskeytyä nopeasti sammutuksen alkaessa.

func job(ctx context.Context) {
    select {
    case <-time.After(time.Hour):
    case <-ctx.Done():
        return // bail out early
    }
}

Odottamisen rajaaminen

Älkää odottako jumiutuneita tehtäviä ikuisesti. Käyttäkää aikakatkaisukontekstia, jotta sammutus valmistuu, vaikka tehtävä juuttuisi.

shutCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

WaitGroup-rakenteet omissa ajastimissa

Jos toteutatte ajastimen itse gorutiineilla, seuratkaa niitä sync.WaitGroup-rakenteella ja kutsukaa sammutuksen aikana Wait()-metodia.

var wg sync.WaitGroup
wg.Add(1)
go func() { defer wg.Done(); doWork() }()
// shutdown:
wg.Wait()

Älkää aloittako uutta työtä

Kun sammutus alkaa, tickerin tai cronin on lopetettava laukeaminen. Done-kanavan sulkeminen tai kontekstin peruuttaminen varmistaa, että silmukka havaitsee signaalin ja lopettaa uusien suoritusten ajastamisen.

Idempotenssi auttaa

Suunnitelkaa tehtävät niin, että niiden suorittaminen uudelleen on turvallista. Jos tehtävä lopetetaan kesken ja yritetään uudelleen uudelleenkäynnistyksen jälkeen, idempotentti logiikka estää toistuvat vaikutukset, kuten sähköpostien tai veloitusten tekemisen kahdesti.

Kokonaisuus

Kun kaikki yhdistetään, saadaan signaalista ilmoittava konteksti, cronin Stop-toiminnon palauttama tehtävien valmistumista odottava konteksti sekä rajattu aikakatkaisu. Tämä on ajastettujen palveluiden hallitun sammutuksen vakiomalli.

Suoritettava esimerkki: hallittu pysäytys kontekstin avulla

Tämä itsenäinen ohjelma suorittaa jaksottaista työtä ja pysäyttää sen hallitusti kontekstin peruuttamisella odottaen, että käynnissä oleva tikki valmistuu.

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        t := time.NewTicker(5 * time.Millisecond)
        defer t.Stop()
        for {
            select {
            case <-t.C:
                fmt.Println("working")
            case <-ctx.Done():
                fmt.Println("stopping cleanly")
                return
            }
        }
    }()
    time.Sleep(17 * time.Millisecond)
    cancel()   // signal shutdown
    wg.Wait()  // wait for worker to finish
    fmt.Println("shutdown complete")
}

Pikatarkistus

Testatkaa, miten hyvin tunnette tehtävien hallitun sammutuksen.

Kertaus

Opitte tehtävien hallitun sammutuksen:

  • Siepatkaa SIGINT- ja SIGTERM-signaalit mieluiten signal.NotifyContext-toiminnon avulla
  • cron.Stop() palauttaa kontekstin, joka odottaa käynnissä olevien tehtävien valmistumista
  • Välittäkää konteksti tehtäville ja rajoittakaa odotusaikaa aikakatkaisulla
  • Tehkää tehtävistä idempotentteja, jotta niiden uudelleenyritykset ovat turvallisia
Aloita maksutta

Opi Go tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit
51
Oppitunnit
203

Usein kysytyt kysymykset

Onko oppitunti ”Töiden hallittu alasajo” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Go Academy-oppimispolun 3 oppituntia, myös oppitunnin “Töiden hallittu alasajo”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Go Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Töiden hallittu alasajo”?

Pysäytä työt siististi Harjoittelet Go Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Go Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Go Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Töiden hallittu alasajo”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Go Academy-oppitunnilla?

Kyllä. Jokainen Go Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

  1. Aikaperusteinen ajoitus
  2. robfig/cron-kirjasto
  3. Tikkerit aikaväleihin
  4. Töiden hallittu alasajo
← Takaisin: Go Academy