PricingLoginStart free
Swift Academy · leksjon

async let, Task, cancellation

Kjør arbeid parallelt med async let , opprett uavhengige Task -er, og håndter cancellation samarbeidsbasert.

Leksjon 2 av 38 trinn

async let, Task, cancellation er en gratis leksjon i Swift Academy på CoddyKit. Dette er leksjon 2 av 3. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Swift Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Swift Academy inneholder totalt 3 leksjoner.

Dette går vi gjennom

Du skal:

  • Starte arbeid i søskenoppgaver med async let
  • Starte uavhengige enheter via Task { }
  • Reagere på kansellering ved hjelp av kooperative kontroller

Grunnleggende om async let

async let starter underoppgaver parallelt innenfor samme område; du må bruke await før du forlater området.

func loadA() async -> Int { try? await Task.sleep(nanoseconds: 200_000_000); return 1 }
func loadB() async -> Int { try? await Task.sleep(nanoseconds: 200_000_000); return 2 }

Task {
    async let a = loadA()
    async let b = loadB()
    // Both start immediately; awaiting joins them
    let sum = await (a + b)
    print("sum =", sum) // 3
}

Uavhengig Task

Bruk Task {} til å starte en uavhengig oppgave, og bruk senere await t.value for å hente resultatet.

// Create an independent task (not tied to current scope)
func fetchMessage() async -> String {
    try? await Task.sleep(nanoseconds: 150_000_000)
    return "hello"
}

let t = Task { await fetchMessage() }
Task {
    print("from Task:", await t.value)  // waits for the independent task's result
}

Grunnleggende om kansellering

Kansellering er kooperativ. Kontroller med Task.checkCancellation() (kaster feil), eller les Task.isCancelled og returner tidlig.

// A long-running job that checks for cancellation
enum WorkError: Error { case cancelled }

func longJob() async throws -> Int {
    var total = 0
    for i in 1...10 {
        try Task.checkCancellation()        // throws CancellationError if cancelled
        try? await Task.sleep(nanoseconds: 50_000_000)
        total += i
    }
    return total
}

let job = Task { try await longJob() }
Task {
    // Cancel after a short delay
    try? await Task.sleep(nanoseconds: 120_000_000)
    job.cancel()
    do {
        _ = try await job.value
    } catch {
        print("job cancelled")              // expected
    }
}

Kansellering fra forelder til barn

Når foreldreoppgaven kanselleres, oppdager underoppgavene det og bør avslutte raskt etter en kontroll.

// Propagate cancellation from parent to children using async let
func part(_ id: Int) async throws -> String {
    try Task.checkCancellation()
    try? await Task.sleep(nanoseconds: 80_000_000)
    return "P\(id)"
}

Task {
    do {
        async let p1 = part(1)
        async let p2 = part(2)
        // Cancel the whole operation before awaiting
        Task.currentTask?.cancel()   // cancel self -> children see cancellation
        let out = try await [p1, p2].joined(separator: ",")
        print(out)
    } catch {
        print("parent cancelled; children stopped")
    }
}

Retningslinjer

Tips:

  • Bruk async let for søskenoppgaver; bruk alltid await på dem i det samme området.
  • Kanseller med task.cancel(), og kall Task.checkCancellation() inne i arbeidet.
  • Foretrekk små async-funksjoner: De er enkle å kansellere og teste.

Kooperativ kanselleringsatferd

Rask sjekk: Hvordan bør langvarig asynkron kode reagere på kansellering?

Besvar den i den interaktive leksjonen

Oppsummering

Oppsummering: Start søskenoppgaver med async let, start uavhengig arbeid i Task {}, og implementer kooperativ kansellering ved å kontrollere status og avslutte raskt.

Gratis å komme i gang

Lær deg Swift med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
122
Leksjoner
409
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «async let, Task, cancellation» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Swift Academy, inkludert «async let, Task, cancellation», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Swift Academy inneholder totalt 3 leksjoner.

Hva lærer jeg i «async let, Task, cancellation»?

Kjør arbeid parallelt med async let , opprett uavhengige Task -er, og håndter cancellation samarbeidsbasert. Du øver på Swift Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Swift Academy?

Ingen tidligere erfaring er nødvendig. Swift Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 3.

Hvor lang tid tar leksjonen «async let, Task, cancellation»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Swift Academy-leksjonen?

Ja. Alle Swift Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Strukturert samtidighet, async-funksjoner
  2. async let, Task, cancellation
  3. try await og feilpropagering
← Tilbake til Swift Academy