0Pricing
Swift Academy · Lección

Task y cancelación de tareas

Cree tareas estructuradas, compruebe la cancelación y aplique la cancelación cooperativa.

Task y cancelación de tareas es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. 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 4 lecciones en total.

Introducción

`Task` es la unidad fundamental de concurrencia en Swift. Ejecuta trabajo asíncrono y admite la cancelación estructurada para gestionar los recursos correctamente.

Crear una Task

```swift Task { let user = try await fetchUser(id: 1) print(user.name) } ``` `Task` crea un nuevo contexto de ejecución concurrente.

Prioridad de las 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() } ```

Comprobar la cancelación

```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) } } ```

Tareas desvinculadas

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

withTaskCancellationHandler

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

Valores de retorno de Task

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

Suspensión

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

Comprobación rápida

¿Qué método lanza un `CancellationError` si se ha cancelado la tarea?

Repaso

Conceptos clave: • `Task { }` — crea una unidad de trabajo asíncrono • `task.cancel()` + `Task.checkCancellation()` — cancelación cooperativa • `Task.isCancelled` — comprobación mediante consulta • `Task.detached` — no hereda el actor ni la prioridad • `Task.sleep(for:)` — retraso no bloqueante Siguiente: async let.

Preguntas frecuentes

¿La lección «Task y cancelación de tareas» es gratis?

Sí — el texto completo de «Task y cancelación de tareas» 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 4 lecciones en total.

¿Qué aprenderé en «Task y cancelación de tareas»?

Cree tareas estructuradas, compruebe la cancelación y aplique la cancelación 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 4.

¿Cuánto tiempo toma la lección «Task y cancelación de tareas»?

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. Sintaxis de async/await y llamadas a funciones asíncronas
  2. Task y cancelación de tareas
  3. async let y tareas hijas concurrentes
  4. Actores: protección del estado mutable compartido
← Volver a Swift Academy