TaskGroup para el paralelismo
Use withTaskGroup para ejecutar tareas hijas en paralelo, iterar los resultados a medida que llegan y gestionar los fallos con la variante que lanza errores.
TaskGroup para el paralelismo es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 1 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.
¿Por qué usar TaskGroup?
TaskGroup inicia muchas tareas hijas en paralelo y recopila los resultados de forma segura. El grupo finaliza solo cuando todas las tareas hijas terminan.
- Créelas con group.addTask
- Procese los resultados con for await
- Use la variante throwing para propagar errores
Crear y recopilar
Cree tareas hijas con addTask e itere por los resultados a medida que llegan mediante for await.
func work(_ n: Int) async -> Int {
try? await Task.sleep(nanoseconds: UInt64(50_000_000 * n)) // simulate delay
return n * n
}
Task {
let result = await withTaskGroup(of: Int.self) { group in
for i in 1...4 {
group.addTask { await work(i) } // spawn child
}
var sum = 0
for await value in group { // values as they finish
sum += value
}
return sum
}
print("sum =", result) // 1^2+2^2+3^2+4^2 = 30
}Agregar resultados
Un grupo es una secuencia asíncrona de resultados; redúzcala o recórrala para construir un único valor de retorno.
func sumSquares(_ n: Int) async -> Int {
await withTaskGroup(of: Int.self) { group in
(1...n).forEach { i in
group.addTask { await work(i) }
}
return await group.reduce(0, +) // reduce over async sequence
}
}
Task {
print(await sumSquares(5)) // 55
}Grupos con errores
Use withThrowingTaskGroup para propagar el primer error; cancele las tareas hijas restantes para evitar trabajo innecesario.
enum CalcError: Error { case boom(Int) }
func risky(_ i: Int) async throws -> Int {
try await Task.sleep(nanoseconds: 30_000_000)
if i == 3 { throw CalcError.boom(i) }
return i
}
Task {
do {
let total = try await withThrowingTaskGroup(of: Int.self) { group in
for i in 1...5 { group.addTask { try await risky(i) } }
var sum = 0
do {
for try await v in group { sum += v }
return sum
} catch {
// Cancel remaining children on error
group.cancelAll()
throw error
}
}
print("total:", total)
} catch {
print("failed:", error) // boom(3)
}
}Cancelar hijos
Llame a group.cancelAll() para solicitar la cancelación. Las tareas hijas deben comprobar Task.isCancelled (o Task.checkCancellation()) y salir rápidamente.
func slow(_ i: Int) async -> Int {
for _ in 0..<5 {
if Task.isCancelled { return -1 } // observe cancellation cooperatively
try? await Task.sleep(nanoseconds: 20_000_000)
}
return i * 10
}
Task {
let value = await withTaskGroup(of: Int.self) { group in
for i in 1...3 { group.addTask { await slow(i) } }
// cancel quickly (e.g., user navigated away)
group.cancelAll()
// Still need to drain results; cancelled children should exit fast
var out = 0
for await v in group { out += v }
return out
}
print("after cancel, collected:", value)
}Pautas
Consejos:
- Prefiera los grupos de tareas cuando el número de tareas hijas sea dinámico.
- Use la variante throwing para un comportamiento que falle rápidamente.
- Procese siempre todos los resultados del grupo, incluso después de cancelarlo.
- Mantenga las tareas hijas pequeñas para que la cancelación responda con rapidez.
Semántica de unión estructurada
Comprobación rápida: ¿Qué garantiza withTaskGroup?
Repaso
Repaso: Use withTaskGroup para iniciar trabajo en paralelo e iterar por los resultados a medida que llegan, y prefiera la variante throwing para fallar rápidamente y cancelar el resto.
Preguntas frecuentes
¿La lección «TaskGroup para el paralelismo» es gratis?
Sí — el texto completo de «TaskGroup para el paralelismo» 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 «TaskGroup para el paralelismo»?
Use withTaskGroup para ejecutar tareas hijas en paralelo, iterar los resultados a medida que llegan y gestionar los fallos con la variante que lanza errores. 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 1 de 3.
¿Cuánto tiempo toma la lección «TaskGroup para el paralelismo»?
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
- TaskGroup para el paralelismo
- Actores, aislamiento de datos y nonisolated
- Sendable y comprobación de seguridad de hilos