0Pricing
Swift Academy · Aula

TaskGroup para paralelismo

Use withTaskGroup para executar tarefas filhas em paralelo, percorrer os resultados à medida que chegam e tratar falhas com a variante que lança erros.

TaskGroup para paralelismo é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 3 aulas no total.

Por que usar TaskGroup?

TaskGroup inicia muitas tarefas filhas em paralelo e coleta os resultados com segurança. O grupo termina somente quando todas as filhas são concluídas.

  • Crie tarefas com group.addTask
  • Consuma resultados com for await
  • Use a variante que lança erros para propagar erros

Criar e coletar

Crie tarefas filhas com addTask e percorra os resultados à medida que chegam usando 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

Um grupo é uma sequência assíncrona de resultados; reduza-a ou percorra-a em um laço para construir um ú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 que lançam erros

Use withThrowingTaskGroup para propagar o primeiro erro; cancele as filhas restantes para interromper trabalho desperdiçado.

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 tarefas filhas

Chame group.cancelAll() para solicitar o cancelamento. As filhas devem verificar Task.isCancelled (ou Task.checkCancellation()) e sair rapidamente.

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

Diretrizes

Dicas:

  • Prefira grupos de tarefas quando o número de filhas for dinâmico.
  • Use a variante que lança erros para um comportamento de falha rápida.
  • Sempre esvazie o grupo (percorrendo os resultados), mesmo após o cancelamento.
  • Mantenha as tarefas filhas pequenas para que o cancelamento seja responsivo.

Semântica de junção estruturada

Verificação rápida: o que withTaskGroup garante?

Recapitulação

Recapitulação: use withTaskGroup para iniciar trabalhos em paralelo, percorrer os resultados à medida que chegam e prefira a variante que lança erros para falhar rapidamente e cancelar o restante.

Perguntas Frequentes

A aula “TaskGroup para paralelismo” é grátis?

Sim — o texto completo de “TaskGroup para paralelismo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 3 aulas no total.

O que vou aprender em “TaskGroup para paralelismo”?

Use withTaskGroup para executar tarefas filhas em paralelo, percorrer os resultados à medida que chegam e tratar falhas com a variante que lança erros. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.

Quanto tempo leva a aula “TaskGroup para paralelismo”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. TaskGroup para paralelismo
  2. Atores e isolamento de dados, nonisolated
  3. Sendable e verificação de segurança entre threads
← Voltar para Swift Academy