0Pricing
Swift Academy · Lezione

Task e cancellazione dei task

Creare task strutturati, verificare la cancellazione e implementare la cancellazione cooperativa.

Task e cancellazione dei task è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. 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 4 lezioni in totale.

Introduzione

`Task` è l'unità fondamentale della concorrenza in Swift. Esegue operazioni asincrone e supporta la cancellazione strutturata per una gestione pulita delle risorse.

Creare un Task

```swift Task { let user = try await fetchUser(id: 1) print(user.name) } ``` `Task` crea un nuovo contesto di esecuzione concorrente.

Priorità dei Task

```swift Task(priority: .userInitiated) { await loadContent() } Task(priority: .background) { await prefetch() } Task(priority: .utility) { await syncData() } ```

Task.cancel()

```swift var task: Task? func startLoading() { task = Task { await heavyWork() } } func stopLoading() { task?.cancel() } ```

Verificare la cancellazione

```swift func process() async throws { for item in items { try Task.checkCancellation() // throws if cancelled process(item) } } ```

Task.isCancelled

```swift func stream() async { while !Task.isCancelled { let data = await fetch() emit(data) } } ```

Task distaccati

```swift Task.detached(priority: .background) { // NOT inheriting actor context or priority of the caller await heavyBackgroundWork() } ```

withTaskCancellationHandler

```swift await withTaskCancellationHandler { await doWork() } onCancel: { cleanup() } ```

Valori restituiti dai Task

```swift let task = Task { 6 * 7 } let result = await task.value // 42 ```

Sospensione

```swift try await Task.sleep(for: .seconds(2)) // Swift 5.7+ try await Task.sleep(nanoseconds: 1_000_000_000) // 1 second ```

Verifica rapida

Quale metodo genera una `CancellationError` se il task è stato cancellato?

Riepilogo

Concetti chiave: • `Task { }` — crea un'unità di lavoro asincrono • `task.cancel()` + `Task.checkCancellation()` — cancellazione cooperativa • `Task.isCancelled` — verifica tramite interrogazione periodica • `Task.detached` — nessuna ereditarietà di actor o priorità • `Task.sleep(for:)` — ritardo non bloccante Prossimo argomento: async let.

Domande Frequenti

La lezione «Task e cancellazione dei task» è gratuita?

Sì — il testo completo di «Task e cancellazione dei task» è 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 4 lezioni in totale.

Cosa imparerò in «Task e cancellazione dei task»?

Creare task strutturati, verificare la cancellazione e implementare la cancellazione cooperativa. 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 4.

Quanto tempo richiede la lezione «Task e cancellazione dei task»?

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. Sintassi async/await e chiamata di funzioni asincrone
  2. Task e cancellazione dei task
  3. async let e task figli concorrenti
  4. Actor: proteggere lo stato mutabile condiviso
← Torna a Swift Academy