async let y TaskGroup en Swift: paralelismo real con structured concurrency

27 de julio de 2026Por Angel Carrero1 min de lectura
async let y TaskGroup en Swift: paralelismo real con structured concurrency

La concurrencia estructurada de Swift garantiza que las tareas hijas terminan antes de que el scope que las creó continúe. async let lanza tareas en paralelo con sintaxis mínima, mientras que TaskGroup permite un número dinámico de tareas paralelas con recolección de resultados.

async let: paralelismo declarativo

func cargarPerfil(id: Int) async throws -> String {
    // Las dos descargas empiezan en paralelo
    async let nombre = obtenerNombre(id: id)
    async let avatar = obtenerAvatar(id: id)

    // await en ambas: espera a que terminen las dos
    let (n, a) = try await (nombre, avatar)
    return "(n) | (a.count) bytes"
}

TaskGroup: número dinámico de tareas

func descargarTodo(urls: [URL]) async throws -> [Data] {
    try await withThrowingTaskGroup(of: Data.self) { grupo in
        for url in urls {
            grupo.addTask {
                let (data, _) = try await URLSession.shared.data(from: url)
                return data
            }
        }
        var resultados: [Data] = []
        for try await dato in grupo {
            resultados.append(dato)
        }
        return resultados
    }
}

Cancelación automática

Si alguna tarea del grupo lanza un error, el grupo cancela las restantes. También puedes comprobar Task.isCancelled dentro de una tarea larga y salir ordenadamente:

group.addTask {
    for i in 0...1000 {
        if Task.isCancelled { break }
        procesarElemento(i)
    }
}

El error más frecuente: mutar estado compartido

// MAL: condicion de carrera
var total = 0
await withTaskGroup(of: Int.self) { g in
    g.addTask { 1 }
    g.addTask { 2 }
    for await n in g { total += n }  // peligroso si total es global
}

// BIEN: recoger en el cuerpo del for-await
var acumulado = 0
for await n in grupo { acumulado += n }

Sigue leyendo