0Pricing
Swift Academy · Lezione

async let, Task e cancellazione

Esegua il lavoro in parallelo con async let , crei Task indipendenti e gestisca la cancellation in modo cooperativo.

async let, Task e cancellazione è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 3 lezioni in totale.

Cosa tratteremo

Imparerà a:

  • Avviare lavoro tra task fratelli con async let
  • Avviare unità indipendenti tramite Task { }
  • Rispondere all'annullamento usando controlli cooperativi

Nozioni di base su async let

async let avvia task figli in parallelo all'interno dello stesso ambito; deve usare await prima di uscire dall'ambito.

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
}

Task indipendente

Utilizzi Task {} per avviare un task indipendente e successivamente await t.value per ottenere il risultato.

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

Nozioni di base sull'annullamento

L'annullamento è cooperativo. Verifichi la condizione con Task.checkCancellation(), che genera un errore, oppure legga Task.isCancelled e termini in anticipo.

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

Il genitore annulla i figli

Quando il task genitore viene annullato, i task figli lo rilevano e dovrebbero terminare rapidamente dopo una verifica.

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

Linee guida

Suggerimenti:

  • Utilizzi async let per i task fratelli; li attenda sempre nello stesso ambito.
  • Annulli il task con task.cancel() e, all'interno del lavoro, chiami Task.checkCancellation().
  • Preferisca funzioni asincrone piccole: sono facili da annullare e da testare.

Comportamento dell'annullamento cooperativo

Verifica rapida: come dovrebbe reagire all'annullamento il codice asincrono di lunga durata?

Riepilogo

Riepilogo: avvii task fratelli con async let, avvii lavoro indipendente con Task {} e implementi l'annullamento cooperativo verificando la condizione e terminando rapidamente.

Domande Frequenti

La lezione «async let, Task e cancellazione» è gratuita?

Sì — il testo completo di «async let, Task e cancellazione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 3 lezioni in totale.

Cosa imparerò in «async let, Task e cancellazione»?

Esegua il lavoro in parallelo con async let , crei Task indipendenti e gestisca la cancellation in modo cooperativo. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 3.

Quanto tempo richiede la lezione «async let, Task e cancellazione»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Concorrenza strutturata e funzioni async
  2. async let, Task e cancellazione
  3. try await e propagazione degli errori
← Torna a Swift Academy