0Pricing
Swift Academy · Lección

async let, Task y cancelación

Ejecute trabajo en paralelo con async let , cree Task s independientes y gestione la cancellation de forma cooperativa.

async let, Task y cancelación es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 3 lecciones en total.

Lo que veremos

En esta lección:

  • Inicie trabajo entre hermanos con async let
  • Inicie unidades independientes mediante Task { }
  • Responda a la cancelación mediante comprobaciones cooperativas

Conceptos básicos de async let

async let inicia tareas hijas en paralelo dentro del mismo ámbito; debe usar await antes de salir de él.

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 independiente

Use Task {} para iniciar una tarea independiente y, posteriormente, await t.value para obtener su resultado.

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

Conceptos básicos de la cancelación

La cancelación es cooperativa. Compruébela con Task.checkCancellation() (lanza un error) o lea Task.isCancelled y finalice la ejecución antes de tiempo.

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

Cancelación del padre → hijos

Cuando se cancela la tarea padre, las tareas hijas lo detectan y deberían salir rápidamente después de una comprobación.

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

Pautas

Consejos:

  • Use async let para tareas hermanas; siempre use await para esperarlas en el mismo ámbito.
  • Cancele con task.cancel() y, dentro del trabajo, llame a Task.checkCancellation().
  • Prefiera funciones asíncronas pequeñas: son fáciles de cancelar y probar.

Comportamiento de la cancelación cooperativa

Comprobación rápida: ¿Cómo debería reaccionar el código asíncrono de larga duración a la cancelación?

Repaso

Repaso: Inicie tareas hermanas con async let, lance trabajo independiente en Task {} e implemente la cancelación cooperativa comprobando la cancelación y saliendo rápidamente.

Preguntas frecuentes

¿La lección «async let, Task y cancelación» es gratis?

Sí — el texto completo de «async let, Task y cancelación» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 3 lecciones en total.

¿Qué aprenderé en «async let, Task y cancelación»?

Ejecute trabajo en paralelo con async let , cree Task s independientes y gestione la cancellation de forma cooperativa. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.

¿Cuánto tiempo toma la lección «async let, Task y cancelación»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Concurrencia estructurada y funciones async
  2. async let, Task y cancelación
  3. try await y propagación de errores
← Volver a Swift Academy